Docstoc

نحو برمجة كائنية التوجه

Document Sample
نحو برمجة كائنية التوجه Powered By Docstoc
					‫‪ Visual Basic‬ﻟﻠﺠﻤﻴﻊ‬
       ‫ﻧﺤﻮ ﺑﺮﻣﺠﺔ آﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ ‪OOP‬‬




                           ‫ﺑﻘﻠﻢ‬
                   ‫ﺗﺮآﻲ اﻟﻌﺴﻴﺮي‬
                 ‫ﺑﺴﻢ اﷲ اﻟﺮﺣﻤﻦ اﻟﺮﺣﻴﻢ‬




‫ُ ْﺤ ﻧﻚ ﻟ ﻋ ْﻢ ﻟﻨ إﻟ ﻣ ﻋﻠ ْﺘﻨ إﻧﻚ أ ْﺖ‬
‫)) ﺳﺒ َﺎ َ َ َﺎ ِﻠ َ َ َﺎ ِ ﱠﺎ َﺎ َ ﱠﻤ َ َﺎ ِ ﱠ َ َﻧ َ‬
                     ‫ْﻌﻠ ُ ْﺤﻜ ُ‬
                  ‫اﻟ َ ِﻴﻢ اﻟ َ ِﻴﻢ ((‬
                                                                       ‫اهﺪاء‬
               ‫اهﺪي هﺬا اﻟﻜﺘﺎب ﺑﺒﺎﻗﺔ ورد ﻣﻌﻄﺮة اﻟﻰ اﻟﺤﺒﻴﺒﺔ اﻟﻐﺎﻟﻴﺔ،‬
                                          ‫اﻟﺘﻲ وﻗﻒ اﻟﻘﻠﻢ ﺣﺎﺋﺮا ﻋﻨﺪهﺎ‬
                                                  ‫ﻣﺤﺎوﻻ ﺗﺮﺗﻴﺐ اﻟﺤﺮوف‬
                                                    ‫ﻟﻴﻜﻮن ﻣﻨﻬﺎ آﻠﻤﺎت‬
                                      ‫ﺗﺼﻒ ﺷﺮارة ﻣﻦ ﻟﻬﻴﺐ ﺣﺒﻲ ﻟﻬﺎ،‬
                                                    ‫واﻟﺘﻲ ﻣﻬﻤﺎ ﺻﻨﻌﺖ‬
                                           ‫ﻣﺎ وﻓﻴﺖ وﻻ آﻔﻴﺖ ﻓﻲ ﺣﻘﻬﺎ‬
                                              ‫وﻟﻮ ﺑﻘﺪر اﺧﻤﺺ ﻗﺪﻣﻬﺎ...‬

                             ‫اﻟﻴﻚ ﻳﺎ اﻣﻲ اﻟﺤﺒﻴﺒﺔ اهﺪي هﺬا اﻟﻜﺘﺎب...‬




‫اﺑﻨﻚ اﻟﻤﺨﻠﺺ،‬
          ‫‪ Visual Basic‬ﻟﻠﺠﻤﻴﻊ‬
                                             ‫ﻧﺤﻮ ﺑﺮﻣﺠﺔ آﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ ‪OOP‬‬
                                                                   ‫اﻟﻄﺒﻌﺔ اﻻوﻟﻰ 2002‬



‫* ﺣﻘﻮق آﺘﺎب "‪ Visual Basic‬ﻟﻠﺠﻤﻴﻊ – ﻧﺤﻮ ﺑﺮﻣﺠﺔ آﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ ‪ "OOP‬ﻣﺤﻔﻮﻇﺔ ﻟﻠﻤﺆﻟﻒ وﻻ ﻳﺤﻖ‬
‫ﻷي ﺷﺨﺺ او ﺟﻬﺔ رﺳﻤﻴﺔ إﻋﺎدة ﻧﺸﺮ هﺬا اﻟﻜﺘﺎب او ﺟﺰء ﻣﻨﻪ ﺑﺄي وﺳـﻴﻠﺔ دون اﻻذن اﻟﺨﻄـﻲ ﻣـﻦ‬
                                                                              ‫اﻟﻤﺆﻟﻒ.‬


‫* اﺳﻤﺎء اﻟﺒﺮاﻣﺞ اﻟﻤـﺬآﻮرة ﻓـﻲ هـﺬا اﻟﻜﺘـﺎب ﻣﺜـﻞ ‪ Windows ،Visual Basic‬وﻏﻴﺮهـﺎ هـﻲ ﻋﻼﻣـﺎت‬
‫ﺗﺠﺎرﻳﺔ ﻣﺴﺠﻠﺔ ﻻﺻﺤﺎﺑﻬﺎ، واﻟﻤﺆﻟﻒ ﻳﺤﺘـﺮم هـﺬﻩ اﻟﻌﻼﻣـﺎت وﻳﻘـﺮ ﺑﻬـﺎ ﻟﻤﺎﻟﻴﻜﻬـﺎ ﺳـﻮاء آـﺎﻧﻮا اﻓـﺮاد او‬
                                               ‫ﺷﺮآﺎت او أي ﺟﻬﺔ ﺗﻨﻈﻴﻤﻴﺔ، وﻟﻢ ﻳﺘﻢ ذآﺮهﺎ ﻟﻼﺧﺘﺼﺎر.‬

‫* ﺗﻢ اﺧﺘﺒﺎر اﻟﻤﺎدة اﻟﻌﻠﻤﻴﺔ ﻓﻲ هﺬا اﻟﻜﺘﺎب واﻟﺘﺤﻘـﻖ ﻣﻨﻬـﺎ وﻣﺮاﺟﻌﺘﻬـﺎ، اﻻ ان اﻟﻤﺆﻟـﻒ ﻏﻴـﺮ ﻣﺴـﺌﻮل‬
‫ﺑﺄي ﺷﻜﻞ ﻣﻦ اﻻﺷﻜﺎل ﻋﻦ اﻻﺿﺮار اﻟﻨﺎﺗﺠﺔ ﺳﻮاء ﺑﺘﻄﺒﻴﻖ اﻟﻤﻌﻠﻮﻣﺎت ﻓﻲ هﺬا اﻟﻜﺘﺎب، او اﺳـﺘﺨﺪام‬
                                                                 ‫اﻻآﻮاد او اﻟﺒﺮاﻣﺞ اﻟﺘﺎﺑﻌﺔ ﻟﻪ.‬

‫* ﺟﻤﻴﻊ اﻻراء اﻟﻤﻮﺟﻮدة ﻓﻲ هﺬا اﻟﻜﺘﺎب ﺗﻌﺒﺮ ﻋﻦ رأي اﻟﻤﺆﻟﻒ اﻟﺸﺨﺼﻲ ﺣﺘﻰ ﻟﻮ ﻟﻢ ﺗﻮﺛﻖ ﺑﺎﻣﺜﻠﺔ او‬
                                                                           ‫ادﻟﺔ ﺣﺴﻴﺔ.‬

                ‫* اﻟﻜﺘﺎب ﻣﺠﺎﻧﻲ 001% وﻻ ﻳﺤﻖ ﻻي ﺷﺨﺺ ﺑﻴﻌﻪ او اﺳﺘﻐﻼﻟﻪ ﺑﺄي ﺷﻜﻞ ﺗﺠﺎري.‬
                                                                         ‫اﻟﻤﺤﺘﻮﻳﺎت‬
‫ﺷﻜﺮ وﺗﻘﺪﻳﺮ ----------------------------------------------------- ا‬
‫---------------------------------------------------- ب‬     ‫اﻟﻤﻘﺪﻣﺔ‬

                                                           ‫اﻟﺠﺰء اﻻول: اﻻﺳﺎﺳﻴﺎت‬
‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮف ﻋﻠﻰ ‪2 -------------------------- Visual Basic‬‬
‫ﺑﻴﺌﺔ اﻟﺘﻄﻮﻳﺮ اﻟﻤﺘﻜﺎﻣﻠﺔ ‪2 ------------------------------------------- IDE‬‬
‫ﻧﻮاﻓﺬ ﺑﻴﺌﺔ اﻟﺘﻄﻮﻳﺮ اﻟﻤﺘﻜﺎﻣﻠﺔ --------------------------------- 3‬
‫ﻗﻮاﺋﻢ ﺑﻴﺌﺔ اﻟﺘﻄﻮﻳﺮ اﻟﻤﺘﻜﺎﻣﻠﺔ --------------------------------- 9‬
‫اﺷﺮﻃﺔ اﻻدوات --------------------------------------------- 21‬
‫آﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺠﻚ اﻻول ------------------------------------------------ 21‬
‫اﻟﺨﻄﻮة اﻻوﻟﻰ: ﻓﻜﺮة اﻟﺒﺮﻧﺎﻣﺞ ----------------------------- 21‬
‫اﻟﺨﻄﻮة اﻟﺜﺎﻧﻴﺔ: إﻧﺸﺎء اﻟﻤﺸﺮوع --------------------------- 21‬
‫اﻟﺨﻄﻮة اﻟﺜﺎﻟﺜﺔ: ﺗﺼﻤﻴﻢ اﻟﻮاﺟﻬﺔ ---------------------------- 31‬
‫اﻟﺨﻄﻮة اﻟﺮاﺑﻌﺔ: آﺘﺎﺑﺔ اﻟﺘﻌﻠﻴﻤﺎت --------------------------- 41‬
‫اﻟﺨﻄﻮة اﻟﺨﺎﻣﺴﺔ: اﻟﺘﺠﺮﺑﺔ واﻟﺘﻌﺪﻳﻞ ----------------------- 51‬
‫اﻟﺨﻄﻮة اﻟﺴﺎدﺳﺔ: اﻟﺘﺮﺟﻤﺔ -------------------------------- 61‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ: اﻟﻨﻤﺎذج واﻻدوات --------------------------------71‬
‫اﻟﺨﺼﺎﺋﺺ اﻟﻤﺸﺘﺮآﺔ ------------------------------------------------ 71‬
‫ﺧﺎﺻﻴﺔ اﻻﺳﻢ ‪19 ------------------------------------- Name‬‬
‫ﺧﺼﺎﺋﺺ اﻟﻤﻮﻗﻊ واﻟﺤﺠﻢ ------------------------------------ 91‬
‫ﺧﺼﺎﺋﺺ اﻻﺣﺘﻀﺎن ------------------------------------------ 02‬
‫ﺧﺎﺻﻴﺔ اﻟﺨﻂ ‪21 ------------------------------------------ Font‬‬
‫ﺧﺼﺎﺋﺺ اﻟﻠﻮن ---------------------------------------------- 22‬
‫ﺧﺼﺎﺋﺺ اﻟﺠﺪوﻟﺔ -------------------------------------------- 32‬
‫ﺧﺼﺎﺋﺺ ﻣﺆﺷﺮ اﻟﻔﺄرة --------------------------------------- 42‬
‫ﺧﺎﺻﻴﺔ اﻟﺘﻌﺮﻳﺐ ‪25 ------------------------------ RightToLeft‬‬
‫ﺧﺎﺻﻴﺔ اﻟﻤﻘﺒﺾ ‪27 -------------------------------------hWnd‬‬
‫ﺧﺼﺎﺋﺺ اﺧﺮى ---------------------------------------------- 72‬
‫اﻟﻄﺮق اﻟﻤﺸﺘﺮآﺔ --------------------------------------------------- 82‬
‫اﻟﻄﺮﻳﻘﺔ ‪28 ---------------------------------------------- Move‬‬
‫اﻟﻄﺮﻳﻘﺔ ‪29 ----------------------------------------- SetFocus‬‬
‫اﻟﻄﺮﻳﻘﺔ ‪30 -------------------------------------------- ZOrder‬‬
‫اﻟﻄﺮﻳﻘﺔ ‪30 ------------------------------------------- Refresh‬‬
‫اﻻﺣﺪاث اﻟﻤﺸﺘﺮآﺔ ------------------------------------------------- 13‬
‫اﺣﺪاث اﻟﻔﺄرة ------------------------------------------------ 23‬
‫اﺣﺪاث اﻟﺘﺮآﻴﺰ ----------------------------------------------- 43‬
‫اﺣﺪاث ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﻴﺢ -------------------------------------- 53‬
‫ﺣﺪث اﻟﺘﻐﻴﻴﺮ ‪37 ------------------------------------- Change‬‬
‫ﻧﺎﻓﺬة اﻟﻨﻤﻮذج ------------------------------------------------------- 73‬
‫ﺧﺼﺎﺋﺺ اﻟﻨﻤﻮذج -------------------------------------------- 73‬
‫ﻃﺮق اﻟﻨﻤﻮذج ----------------------------------------------- 34‬
‫اﺣﺪاث اﻟﻨﻤﻮذج --------------------------------------------- 84‬
‫اﻟﻘﻮاﺋﻢ ‪52 --------------------------------------------- Menus‬‬
‫اﻻدوات اﻟﺪاﺧﻠﻴﺔ ---------------------------------------------------- 35‬
‫أداة اﻟﻌﻨﻮان ‪53 ------------------------------------------ Label‬‬
‫أداة اﻟﻨﺺ ‪54 ---------------------------------------- TextBox‬‬
‫زر اﻻواﻣﺮ ‪60 ------------------------------ Command Button‬‬
‫أداة اﻻﺧﺘﻴﺎر ‪60 ------------------------------------ CheckBox‬‬
‫زر اﻻﺧﺘﻴﺎر ‪61 ---------------------------------- OptionButton‬‬
‫أداة اﻟﻘﺎﺋﻤﺔ ‪61 --------------------------------------- ListBox‬‬
‫أداة اﻟﻘﺎﺋﻤﺔ ‪64 ----------------------------------- ComboBox‬‬
‫أداة اﻟﺼﻮرة ‪64 ------------------------------------ PictureBox‬‬
‫أداة اﻟﺼﻮرة ‪64 ------------------------------------------ Image‬‬
‫اﺷﺮﻃﺔ اﻟﺘﻤﺮﻳﺮ ‪65 --------------------------------- ScrollBars‬‬
‫ادوات اﻟﻤﻠﻔﺎت ---------------------------------------------- 66‬
‫ادوات اﺧﺮى ------------------------------------------------- 86‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻟﺚ: ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ ‪70 ---------------------------- BASIC‬‬
‫اﻟﻤﺘﻐﻴﺮات واﻟﺜﻮاﺑﺖ -------------------------------------------------- 07‬
‫ﻗﺎﺑﻠﻴﺔ اﻟﺮؤﻳﺔ وﻋﻤﺮ اﻟﺤﻴﺎة ---------------------------------- 07‬
‫اﻟﻤﺘﻐﻴﺮات --------------------------------------------------- 57‬
‫اﻟﺜﻮاﺑﺖ ------------------------------------------------------ 38‬
‫اﻟﺘﺮآﻴﺒﺎت واﻟﻤﺼﻔﻮﻓﺎت ---------------------------------------------- 58‬
‫ﺗﺮآﻴﺒﺎت ‪85 -------------------------------------------- Enum‬‬
‫ﺗﺮآﻴﺒﺎت ﻣﻦ اﻟﻨﻮع ‪87 ------------------------------------- UDT‬‬
‫اﻟﻤﺼﻔﻮﻓﺎت -------------------------------------------------- 98‬
‫اﻟﻤﺠﻤﻮﻋﺎت -------------------------------------------------- 39‬
‫اﻻﺟﺮاءات واﻟﺪوال --------------------------------------------------- 69‬
‫اﻻرﺳﺎل ﺑﺎﻟﻤﺮﺟﻊ او اﻟﻘﻴﻤﺔ --------------------------------- 89‬
‫ارﺳﺎل اﻧﻮاع اﺧﺮى ---------------------------------------- 001‬
‫ﺗﺨﺼﻴﺺ اﻟﻤﺘﻐﻴﺮات اﻟﻤﺮﺳﻠﺔ ----------------------------- 101‬
‫اﻟﺘﺤﻜﻢ ﻓﻲ ﺳﻴﺮ اﻟﺒﺮﻧﺎﻣﺞ ---------------------------------------- 301‬
‫اﻟﺘﻔﺮع ﺑﺎﺳﺘﺨﺪام ‪103 -------------------------------------- IF‬‬
‫اﻟﺘﻔﺮع ﺑﺎﺳﺘﺨﺪام ‪105 --------------------------------- Select‬‬
‫اﻟﺤﻠﻘﺎت اﻟﺘﻜﺮارﻳﺔ ----------------------------------------- 701‬
‫ﺗﺤﺴﻴﻦ اﻟﻜﻔﺎءة --------------------------------------------------- 011‬
‫‪ P-Code‬و ‪110 ---------------------------------- Native Code‬‬
‫اﻋﺪادات ‪112 ----------------------- Advanced Optimization‬‬
‫اﻟﻔﺼﻞ اﻟﺮاﺑﻊ: ﻣﻜﺘﺒﺎت ‪ VB‬و ‪114 ------------------------------ VBA‬‬
‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻻﻋﺪاد ------------------------------------------------ 411‬
‫اﻟﻤﻌﺎﻣﻼت اﻟﺮﻳﺎﺿﻴﺔ ---------------------------------------- 411‬
‫اﻟﺪوال اﻟﺮﻳﺎﺿﻴﺔ -------------------------------------------- 711‬
‫ﺗﻨﺴﻴﻖ اﻻﻋﺪاد -------------------------------------------- 811‬
‫دوال اﺧﺮى ------------------------------------------------- 811‬
‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺤﺮوف ----------------------------------------------- 021‬
‫اﻟﻤﻌﺎﻣﻼت اﻟﺤﺮﻓﻴﺔ ---------------------------------------- 021‬
‫اﻟﺒﺤﺚ واﻻﺳﺘﺒﺪال ---------------------------------------- 221‬
‫ﺗﻨﺴﻴﻖ اﻟﺤﺮوف -------------------------------------------- 321‬
‫دوال اﺧﺮى ------------------------------------------------ 321‬
‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻮﻗﺖ واﻟﺘﺎرﻳﺦ ---------------------------------------- 621‬
‫دوال اﻟﻮﻗﺖ واﻟﺘﺎرﻳﺦ -------------------------------------- 621‬
‫ﺗﻨﺴﻴﻖ اﻟﻮﻗﺖ واﻟﺘﺎرﻳﺦ ------------------------------------ 031‬
‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﻠﻔﺎت واﻟﻤﺠﻠﺪات ----------------------------------- 031‬
‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﻠﻔﺎت --------------------------------------- 131‬
‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺠﻠﺪات ------------------------------------- 131‬
‫اﻟﺒﺤﺚ ﻋﻦ اﻟﻤﻠﻔﺎت واﻟﻤﺠﻠﺪات --------------------------- 331‬
‫ﺗﺤﺮﻳﺮ اﻟﻤﻠﻔﺎت --------------------------------------------- 331‬
‫آﺎﺋﻨﺎت اﺧﺮى ------------------------------------------------------ 831‬
‫آﺎﺋﻦ اﻟﺒﺮﻧﺎﻣﺞ ‪139 ----------------------------------------- App‬‬
‫آﺎﺋﻦ اﻟﺤﺎﻓﻈﺔ ‪140 --------------------------------- Clipboard‬‬
‫آﺎﺋﻦ اﻟﺸﺎﺷﺔ ‪142 ----------------------------------- Screen‬‬
‫آﺎﺋﻦ اﻟﻄﺎﺑﻌﺔ ‪142 -------------------------------------- Printer‬‬
‫اآﺘﺸﺎف اﻻﺧﻄﺎء -------------------------------------------------- 441‬
‫ﻓﻜﺮة ﻋﺎﻣﺔ ------------------------------------------------- 441‬
‫اﻟﻜﺎﺋﻦ ‪147 -------------------------------------------------- Err‬‬
‫اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ: اﻟﺒﺮﻣﺠﺔ آﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ ‪149 ---------------- OOP‬‬
‫ﻣﻘﺪﻣﺔ اﻟﻰ ‪149 ------------------------------------------------- OOP‬‬
‫ﻟﻤﺎذا ‪OOP‬؟ ----------------------------------------------- 051‬
‫ﺳﻤﺎت ‪151 ---------------------------------------------- OOP‬‬
‫ﺑﻨﺎء اول ﻓﺌﺔ ﻣﺒﺴﻄﺔ ------------------------------------- 251‬
‫ﺑﻨﺎء اﻟﻔﺌﺎت --------------------------------------------------------- 351‬
‫ﺑﻨﺎء اﻟﺨﺼﺎﺋﺺ --------------------------------------------- 351‬
‫ﺑﻨﺎء اﻟﻄﺮق ------------------------------------------------ 751‬
‫ﺑﻨﺎء اﻻﺣﺪاث ---------------------------------------------- 851‬
‫ﻣﺜﺎل ﺗﻄﺒﻴﻘﻲ ---------------------------------------------- 261‬
‫اﺳﺘﺨﺪام اﻟﻜﺎﺋﻨﺎت ------------------------------------------------ 561‬
‫ﻋﺒﺎرات وآﻠﻤﺎت ﺧﺎﺻﺔ ﺑﺎﻟﻜﺎﺋﻨﺎت -------------------------- 561‬
‫ﻣﺎهﻲ ﺣﻘﻴﻘﺔ اﻟﻜﺎﺋﻦ ؟ ----------------------------------- 761‬
‫ﺻﻮرة اﻟﻜﺎﺋﻦ ﺑﺎﻟﺬاآﺮة ------------------------------------- 861‬
‫اﻟﺮﺑﻂ ‪171 -------------------------------------------- Binding‬‬
‫وﻻدة وﻣﻮت اﻟﻜﺎﺋﻦ ---------------------------------------- 371‬
‫ارﺳﺎل اﻟﻜﺎﺋﻦ ﺑﺎﻟﻤﺮﺟﻊ او اﻟﻘﻴﻤﺔ ------------------------- 471‬
‫اﻟﻔﺼﻞ اﻟﺴﺎدس: ﺗﻌﺪد اﻟﻮاﺟﻬﺎت واﻟﻮراﺛﺔ -------------------- 571‬
‫ﺗﻌﺪد اﻟﻮاﺟﻬﺎت ‪175 ---------------------------------- Polymorphism‬‬
‫ﺗﻄﺒﻴﻖ ﻋﻤﻠﻲ --------------------------------------------- 671‬
‫اﻟﻮراﺛﺔ ‪178 ---------------------------------------------- Inheritance‬‬
‫ﻣﺤﺎآﺎة اﻟﻮراﺛﺔ ﺑـ ‪180 --------------------------- Visual Basic‬‬
‫ﻋﻼﻗﺔ "ﻳﺤﺘﻮي ﻋﻠﻰ" ------------------------------------- 381‬
‫اﻟﺘﻔﻮﻳﺾ ‪184 ------------------------------------- Delegation‬‬
‫وراﺛﺔ اﻟﻮاﺟﻬﺎت -------------------------------------------- 681‬
‫اﻟﺘﺼﻨﻴﻒ اﻟﻔﺮﻋﻲ ‪188 -------------------------- Subclassing‬‬
‫اﻻهﺮام اﻟﻜﺎﺋﻨﻴﺔ --------------------------------------------------- 981‬
‫اﻟﻌﻼﻗﺎت ﺑﻴﻦ اﻟﻔﺌﺎت -------------------------------------- 091‬
‫ﻓﺌﺎت اﻟﻤﺠﻤﻮﻋﺎت ‪194 ------------------ Collection Classes‬‬
                                                 ‫اﻟﺠﺰء اﻟﺜﺎﻧﻲ: ﺑﺮﻣﺠﺔ ﻗﻮاﻋﺪ اﻟﺒﻴﺎﻧﺎت‬
‫اﻟﻔﺼﻞ اﻟﺴﺎﺑﻊ: ﻣﺪﺧﻠﻚ اﻟﻰ ﻗﻮاﻋﺪ اﻟﺒﻴﺎﻧﺎت --------------------- 0‬
‫ﺗﻘﻨﻴﺎت اﻟﻮﺻﻮل اﻟﻰ اﻟﺒﻴﺎﻧﺎت ----------------------------------------- 0‬
‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ ﻗﻮاﻋﺪ اﻟﺒﻴﺎﻧﺎت ------------------------------------------- 0‬
‫ﻟﻐﺔ اﻻﺳﺘﻌﻼم ‪0 --------------------------------------------------- SQL‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻣﻦ: اﺳﺘﺨﺪام آﺎﺋﻨﺎت ‪0 --------------------------- ADO‬‬
‫اﻟﻜﺎﺋﻦ ‪0 --------------------------------------------------- Connection‬‬
‫اﻟﻜﺎﺋﻦ ‪0 ---------------------------------------------------- Recordset‬‬
‫اﻟﻜﺎﺋﻦ ‪0 --------------------------------------------------- Command‬‬
‫اﻟﻔﺼﻞ اﻟﺘﺎﺳﻊ: اﻻدوات واﻟﺘﻘﺎرﻳﺮ --------------------------------- 0‬
‫أداة ‪0 -------------------------------------------------------- DataGrid‬‬
‫أداة ‪0 --------------------------------------------------------- FlexGrid‬‬
‫اﻻداﺗﻴﻦ ‪ DataCombo‬و ‪0 ------------------------------------- DataList‬‬
‫ﻣﺼﻤﻢ اﻟﺘﻘﺎرﻳﺮ -------------------------------------------------------- 0‬

                                                       ‫اﻟﺠﺰء اﻟﺜﺎﻟﺚ: ﻣﻮاﺿﻴﻊ ﻣﺘﻘﺪﻣﺔ‬
‫اﻟﻔﺼﻞ اﻟﺤﺎدي ﻋﺸﺮ: اﺟﺮاءات ‪0 ------------------------------ API‬‬
‫اﻟﺒﺮﻣﺠﺔ ﺗﺤﺖ ‪0 --------------------------------------------- Windows‬‬
‫ﺗﻄﺒﻴﻘﺎت ﻋﻤﻠﻴﺔ ------------------------------------------------------- 0‬
‫‪ API‬ﻟﻠﻤﺒﺮﻣﺠﻴﻦ اﻟﺸﺠﻌﺎن ﻓﻘﻂ -------------------------------------- 0‬
‫اﻟﻔﺼﻞ اﻟﻌﺎﺷﺮ: اﻻﺳﺘﺨﺪام اﻟﻤﺘﻘﺪم ﻟﻠﻨﻤﺎذج -------------------- 0‬
‫اﻟﺴﺤﺐ واﻻﻟﻘﺎء ------------------------------------------------------- 0‬
‫اﻹﻧﺸﺎء اﻟﺪﻳﻨﺎﻣﻴﻜﻲ ﻟﻼدوات ------------------------------------------ 0‬
‫اﻟﻨﻤﺎذج آﻔﺌﺎت -------------------------------------------------------- 0‬
‫اﻟﺮدود واﻟﺘﺼﻨﻴﻒ اﻟﻔﺮﻋﻲ ﻟﻠﺮﺳﺎﺋﻞ ----------------------------------- 0‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ ﻋﺸﺮ: ﺑﺮﻣﺠﺔ اﻟﻤﻜﻮﻧﺎت ‪0 ------------------ 1 COM‬‬
‫ﻣﻘﺪﻣﺔ اﻟﻰ ‪0 ----------------------------------------------------- COM‬‬
‫ﻣﺸﺎرﻳﻊ ‪0 ------------------------------------------------ ActiveX EXE‬‬
‫ﻣﺸﺎرﻳﻊ ‪0 ------------------------------------------------ ActiveX DLL‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎﻟﺚ ﻋﺸﺮ: ﺑﺮﻣﺠﺔ اﻟﻤﻜﻮﻧﺎت ‪0 ------------------- 2 COM‬‬
‫ﻣﺸﺎرﻳﻊ ‪0 ----------------------------------------------- ActiveX OCX‬‬
‫ﻣﺴﺎرات اﻟﺘﻨﻔﻴﺬ ‪0 ----------------------------------------- Threading‬‬
‫اﻟﻤﻜﻮﻧﺎت اﻟﻤﻮزﻋﺔ ‪0 -------------------------------------------- DCOM‬‬
                                                         ‫اﻟﺠﺰء اﻟﺮاﺑﻊ: ﺑﺮﻣﺠﺔ اﻻﻧﺘﺮﻧﺖ‬
‫اﻟﻔﺼﻞ اﻟﺮاﺑﻊ ﻋﺸﺮ: ﺻﻔﺤﺎت ‪ DHTML‬اﻟﺪﻳﻨﺎﻣﻴﻜﻴﺔ --------------- 0‬
‫ﻣﻘﺪﻣﺔ اﻟﻰ ‪0 ------------------------------------------------ VBScript‬‬
‫ﻣﻘﺪﻣﺔ اﻟﻰ ‪0 -------------------------------------------------- DHTML‬‬
‫اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ ﻋﺸﺮ: ﺻﻔﺤﺎت ‪ ASP‬ﻟﻠﺨﺎدم -------------------- 0‬
‫ﻣﻘﺪﻣﺔ اﻟﻰ ‪0 ------------------------------------------------------- IIS‬‬
‫آﺎﺋﻨﺎت ‪0 ----------------------------------------------------------- ASP‬‬
‫اﻟﻤﻠﺤﻖ 1: ﻣﺼﺎدر ﻟﻤﺒﺮﻣﺠﻲ ‪0 --------------------- Visual Basic‬‬
‫اﻟﻔﻬﺮس اﻟﻌﺮﺑﻲ ------------------------------------------------- 0‬
‫اﻟﻔﻬﺮس اﻻﻧﺠﻠﻴﺰي ---------------------------------------------- 0‬
                                                 ‫أ‬


                                                                            ‫ﺷﻜﺮ وﺗﻘﺪﻳﺮ‬
         ‫اذا آﺎﻧﺖ اﻻﺳﻤﺎء اﻟﺘﺎﻟﻴﺔ ﻻ ﺗﻌﻨﻲ ﻟﻚ ﺷﻴﺌﺎ، ﻓﻬﻲ ﺗﻌﻨﻲ اﻟﻜﺜﻴﺮ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻲ:‬

‫ﻓﻲ اﻟﺒﺪاﻳﺔ اود ان اﺷﻜﺮ ﺟﻤﻴﻊ آﺘﺎب ﻣﻮﻗﻌﻲ اﻟﺴﺎﺑﻖ "اﻟﻰ اﻟﻘﻤﺔ ﻣـﻊ ‪"Visual Basic‬‬
‫ﻣﺒﺘﺪﺋﺎ ﺑﻌﺎﺷـﻖ اﻻﺳـﻤﺒﻠﻲ اﺣﻤـﺪ اﻟﺸـﻤﺮي، وﻣـﻦ ﻟﻴﺒﻴـﺎ ﻃـﺎرق ﻣﻮﺳـﻰ، واﻟﻤﺒـﺮﻣﺞ‬
‫اﻟﻤﺨﻀﺮم ﺻﺎﻟﺢ اﻟﻐﺎﻣﺪي، وﺧﺒﻴـﺮ اﻟﻔـﻼش إﻳـﺎد زآـﺮي، واﻟﺰﻣﻴـﻞ رود ﺳـﺘﻴﻔﻦ، واﺧـﻲ‬
                                                            ‫ﻋﺒﺪاﷲ اﻟﻌﺴﻴﺮي.‬

‫آﻤﺎ اود ان اﺗﻘﺪم ﺑﺎﻟﺸﻜﺮ اﻟﺠﺰﻳﻞ اﻟـﻰ ﺟﻤﻴـﻊ ﻣﺸـﺮﻓﻲ ‪ vb4arab.com‬واﻟـﺬي ﻳﻌﺘﺒـﺮ‬
‫اآﺒﺮ ﻣﻮﻗﻊ ﻋﺮﺑﻲ ﻳﺨﺘﺺ ﺑﺎﻟـ ‪ ،Visual Basic‬اﺷﻜﺮ اﻻﺳـﺎﺗﺬة: ﻣﺤﻤـﺪ اﻟﺤﻠﺒـﻲ، ﻣﺤﻤـﺪ‬
‫ﺣﻤﻮد، ﺣﺴﻦ اﻟﺤﺮﺑﻲ، وﻟﻴﺪ ﻋﺒﺪاﷲ، ﻃـﺎرق اﻟﻌﺒﻴـﺪ، ﻋﺎﺻـﻔﺔ، ﺻـﺎﻟﺢ اﻟﻌﻨـﺰي، ﻣﺤﻤـﺪ‬
‫اﻟﺪوﺳﺮي، اوراﻧﻮس، ﺳﺎهﺮ، ﺟﺎد واﻟﻤﺆﺳﺲ ﻋﺒﺪاﷲ اﻟﻌﺘﻴﻖ ﻋﻠﻰ آﻞ ﻣﺎ ﻗـﺪﻣﻮﻩ ﻣـﻦ‬
                                      ‫ﺟﻬﻮد ﺟﺒﺎرة ﻟﻤﺒﺮﻣﺠﻲ ‪ Visual Basic‬اﻟﻌﺮب.‬

‫اﺧﺘﺺ ﺑﺎﻟﺸﻜﺮ اﻟﺠﺰﻳﻞ ﻟﻼﺳﺘﺎذ ﺳﺎﻟﻢ اﻟﻤﺎﻟﻜﻲ –ﻣﺸﺮف ﻋﺎم ﺑﻤﻮﻗﻊ ‪ -vb4arab‬ﻋﻠـﻰ‬
‫ﻣﺮاﺟﻌﺘﻪ اﻟﺪﻗﻴﻘﺔ واﻗﺘﺮاﺣﺎﺗﻪ اﻟﻨﻴـﺮة ﻟﻬـﺬا اﻟﻜﺘـﺎب. واﻻﺳـﺘﺎذ ﻗـﺎروط –ﻣـﺪرس ﻣـﺎدة اﻟــ‬
‫‪ JAVA‬و اﻟـ ++‪ C‬ﺑﺠﺎﻣﻌﺔ اﻟﻤﻠـﻚ ﻓﻬـﺪ ﻟﻠﺒﺘـﺮول واﻟﻤﻌـﺎدن- ﻋﻠـﻰ دروﺳـﻪ اﻟﻘﻮﻳـﺔ ﻓـﻲ‬
‫اﺳــﺎﻟﻴﺐ ﺑﺮﻣﺠــﺔ ‪ .OOP‬واﻻﺳــﺘﺎذ دوﻧﻮﻓﺎﻧــﺪ –اﺳــﺘﺎذ ﻓــﻲ ﺑﺮﻧــﺎﻣﺞ اﻟﻠﻐــﺔ اﻻﻧﺠﻠﻴﺰﻳــﺔ‬
‫ﺑﺎﻟﺠﺎﻣﻌﺔ- ﻋﻠﻰ ﻣﻘﺮر ﻓـﻦ آﺘﺎﺑـﺔ اﻟﻤﻘـﺎﻻت واﻋـﺪاد اﻟﺘﻘـﺎرﻳﺮ وارﺷـﺎدي ﻟﻄﺮﻳﻘـﺔ ﺗـﺄﻟﻴﻒ‬
‫اﻟﻜﺘﺐ. وﺷﻜﺮ ﺟﺰﻳﻞ اﻟﻰ اﺳﻄﻮرة اﻟﻤﺒﺮﻣﺠﻴﻦ اﻟﺴـﻴﺪ ﺑـﺮوس ﻣـﺎآﻴﻨﻲ –ﻣﺆﻟـﻒ آﺘـﺎب‬
‫‪ -Hardcore Visual Basic‬ﻋﻠﻰ اﻻذن واﻟﺴـﻤﺎح ﻟـﻲ ﺑﺘﺮﺟﻤـﺔ ﺑﻌـﺾ اﻟﻤﻘﺘﻄﻔـﺎت ﻣـﻦ‬
                                                        ‫آﺘﺎﺑﻪ وﺗﻄﺒﻴﻖ اآﻮادﻩ اﻻﺣﺘﺮاﻓﻴﺔ.‬

‫وﻻ اﻧﺴﻰ ﺷـﻜﺮ اﻟـﺰﻣﻼء ﻓﻬـﺪ اﻟﻌﻤﻴـﺮ، ﻋﺒـﺪاﷲ اﻟﻘﺤﻄـﺎﻧﻲ، ﺳـﻌﺪ اﻟﺪوﺳـﺮي وﻧـﺎﻳﻒ‬
           ‫اﻟﻌﺘﻴﺒﻲ ﻋﻠﻰ اﺧﺘﺒﺎراﺗﻬﻢ اﻟﻘﻮﻳﺔ ﻻآﻮاد ﺑﺮاﻣﺠﻲ وﺗﺼﺤﻴﺢ ﻣﻌﻈﻢ اﺧﻄﺎﺋﻬﺎ.‬

‫واذا آﺎن ﺷﻜﺮ آﻞ هﺆﻻء ﻓﻲ آﻔـﺔ، ﻓـﺎن ﺷـﻜﺮ اﻋـﺰ واﻏﻠـﻰ اﻟﺒﺸـﺮ ﻋﻨـﺪي ﻓـﻲ آﻔـﺔ‬
                 ‫اﺧﺮى. اﻣﻲ واﺑﻲ اﺷﻜﺮآﻤﺎ ﻋﻠﻰ آﻞ ﻣﺎ ﻗﺪﻣﺘﻮﻩ ﻟﻲ ﻓﻲ ﺣﻴﺎﺗﻲ.‬

‫واﺧﻴﺮا، اﺗﻤﻨﻰ ان ﺗﺴﺘﻤﻌﻮا ﺑﻘﺮاءة هﺬا اﻟﻜﺘﺎب واﺳﺄل اﷲ ﺳﺒﺤﺎﻧﻪ وﺗﻌﺎﻟﻰ ان ﻳﺠﻌﻠـﻪ‬
                            ‫ﻣﻦ اﻟﻌﻠﻢ اﻟﺬي ﻳﻨﺘﻔﻊ ﺑﻪ اﻧﻪ ﺳﻤﻴﻊ ﻣﺠﻴﺐ اﻟﺪﻋﻮات.‬
                                               ‫ب‬


                                                                                 ‫اﻟﻤﻘﺪﻣﺔ‬
‫رﺣﻠﺔ ﻋﺸﺮ ﺳﻨﻮات ﻣﻦ ﻋﻤﺮ اﻻﻧﺴﺎن ﻟﻴﺴﺖ آﺮﺣﻠﺔ ﺳﻴﺎﺣﻴﺔ ﺗﺨﺘﻔـﻲ ﺁﺛﺎرهـﺎ ﺑﻤﺠـﺮد‬
‫اﻟﻌﻮدة اﻟﻰ اﻟﻤﻜﺘﺐ ﻓﻲ اﻟﻌﻤﻞ، ﻓﻬﻲ رﺣﻠﺔ ﻃﻮﻳﻠﺔ ﺻـﺎﺣﺒﺘﻬﺎ ﻗـﺮاءات ﻵﻻف اﻟﺼـﻔﺤﺎت‬
‫وﺳﻬﺮات ﺑﻌﺪد اﻟﻨﺠﻮم اﻟﺘﻲ آﻨﺖ اراهﺎ ﺑﻌﺪ اﻧﺼﺎف اﻟﻠﻴـﺎﻟﻲ ﺑﺎﺳـﻄﺎ ﻳـﺪي ﻋﻠـﻰ ﻟﻮﺣـﺔ‬
       ‫اﻟﻤﻔﺎﺗﻴﺢ، ﻣﺘﻮﻏﻼ ﻓﻲ ﺻﺮاﻋﺎت ﻣﻊ اﻟﺴﺎﺣﺮ اﻟﺬي اﺣﺒﺒﺘﻪ وآﺮهﺘﻪ ‪.Visual Basic‬‬
‫ﻋﻼﻗﺔ اﻟﺤﺐ واﻟﻜﺮﻩ ﻟﻴﺴﺖ ﻋﻼﻗﺔ ﺧﻴﺎﻟﻴﺔ آﻤﺎ ﺗﺴﻄﺮهﺎ ﺧﺰﻋﺒﻼت واﺳﺎﻃﻴﺮ اﻟﻌﺸـﺎق،‬
‫ﻓﻤﻨﺬ اﻻﺻﺪار 1‪ VB‬ﺑﺪأ ﻗﻠﺒﻲ ﻳﺨﻔﻖ اﻟﻰ ﺗﻠﻚ اﻟﻠﻐﺔ –ﻣﺒـﺪﺋﻴﺎ- ﺑﺴـﺒﺐ ﻣﺼـﻤﻢ اﻟﻨﻤـﺎذج‬
‫‪ Form Designer‬اﻟﺬي ﺳﺎهﻢ ﻓﻲ ﻧﺴـﻴﺎن اواﻣـﺮ اﻟﻤﺨﺮﺟـﺎت ‪ Locate ،Print‬و ‪Color‬‬
‫ﻟﻜﺘﺎﺑﺔ ﻣﺌﺎت اﻻﺳﻄﺮ -اﺷـﺒﻪ ﺑﺎﻟﻤﺨﻄﻮﻃـﺎت اﻟﻔﺮﻋﻮﻧﻴـﺔ- واﻟﺨﺎﺻـﺔ ﺑﺘﺼـﻤﻴﻢ اﻟﻮاﺟﻬـﺎت.‬
‫وﻟﻜﻦ ﻣﺎ ان ﻟﺒﺜﺖ اﻟﻌﻼﻗﺔ اﻟﻐﺮاﻣﻴﺔ ﺑﺎﻻﺷﺘﻌﺎل، ﺣﺘﻰ ﺑﺪأ ﺷﺮﻳﺎن اﻟﻜﺮﻩ ﻟـ ‪Visual Basic‬‬
‫ﻳﻨﻤﻮ ﺷﻴﺌﺎ ﻓﺸﻴﺌﺎ ﺑﺴـﺒﺐ ﻗﺼـﻮر ‪ Visual Basic‬وﺿـﻌﻔﻪ -اﻟﻌـﺎﺟﺰ ﻋـﻦ اﻟﻤﺮاوﻏـﺔ- ﻋﻨـﺪ‬
‫اﻟﺘﺤﺪث ﻋﻦ ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ ‪ .BASIC‬اﻻ ان ﻋﻼﻗﺔ اﻟﺤﺐ ﺗﻄﻐﻰ ﻋﻠـﻰ ﻋﻼﻗـﺔ اﻟﻜـﺮﻩ ﻣـﻦ‬
‫ﺟﺪﻳﺪ آﻠﻤﺎ اﺳﺘﺨﺪم ﻣﺆﺷﺮ اﻟﻔﺄرة ‪ Mouse‬ﻋﺎﺋﺪا ﻟﺘﺼﻤﻴﻢ اﻟﻮاﺟﻬﺎت ﺑﻤﺼـﻤﻢ اﻟﻨﻤـﺎذج،‬
‫وﺗﻄﻐﻰ ﻋﻼﻗﺔ اﻟﻜﺮﻩ ﻣﺮة اﺧﺮى ﺣـﻴﻦ اﺳـﺘﺨﺪام ﻟﻮﺣـﺔ اﻟﻤﻔـﺎﺗﻴﺢ وآﺘﺎﺑـﺔ اﻻآـﻮاد ﻓـﻲ‬
                                                 ‫ﻧﺎﻓﺬة ﻣﺤﺮر اﻻآﻮاد ‪.Code Window‬‬
‫وآﻤﺎ ﻳﻘﻮﻟـﻮن "اﻟﺤﻴـﺎة ﺗﺠـﺎرب"، ﻓﺒﻌـﺪ ﻋﺸـﺮ ﺳـﻨﻮات ﻣـﻦ اﻟﺒﺮﻣﺠـﺔ ﺑــ ‪،Visual Basic‬‬
‫اآﺘﺸﻔﺖ ان اﻟﻜﻠﻤﺎت -اﻟﺘﻲ ﺑﺪأت ﺑﻬﺎ ﻣﻘﺪﻣﺘﻲ- ﻻ اﺳﺎس ﻟﻬﺎ ﻣﻦ اﻟﺼﺤﺔ! ﻓـ ‪Visual‬‬
‫‪ Basic‬ﻳﻤﻜﻨﻚ ﻣﻦ ﺗﺼﻤﻴﻢ ﻧﻮاﻓﺬ ﺗﻀـﻊ ﻋﻠﻴﻬـﺎ ازرار ‪ Buttons‬وﺧﺎﻧـﺎت ﻧـﺺ ‪،TextBoxes‬‬
‫آﻤﺎ ﻳﻤﻜﻨﻚ ﻣﻦ اﻻﺗﺼﺎل ﺑﻘﻮاﻋﺪ اﻟﺒﻴﺎﻧﺎت ‪ DataBases‬ﻟﺤﻔـﻆ اﻟﺒﻴﺎﻧـﺎت ﻋﻠـﻰ اﻻﻗـﺮاص،‬
‫وهﺬا ﺑﺤﺪ ذاﺗﻪ ﻳﻠﺒﻲ رﻏﺒﺔ ﺁﻻف –ان ﻟﻢ ﻳﻜﻦ ﻣﻼﻳﻴﻦ- اﻟﻤﺒﺮﻣﺠﻴﻦ ﺣﻮل اﻟﻌﺎﻟﻢ ﻟﻴﻘﺘﻨﻌـﻮا‬
                    ‫ان ‪ Visual Basic‬اﻓﻀﻞ ﻣﻨﺼﺔ ﺗﻄﻮﻳﺮ اﻟﺘﻄﺒﻴﻘﺎت ﻋﻠﻰ ﻣﺪى اﻟﺘﺎرﻳﺦ.‬
‫ﻣﻦ ﻧﺎﺣﻴﺔ اﺧﺮى، ﻻ ﻳﻤﻜﻨﻚ ‪ Visual Basic‬ﻣـﻦ ادارة اﻟـﺬاآﺮة ‪Memory Management‬‬
    ‫ـ‬         ‫ـ ـ‬            ‫ـ‬     ‫ـ‬
‫ﺑﻄﺮﻳﻘ ـﺔ ﺳ ـﻬﻠﺔ –ﻣﻘﻨﻌ ـﺔ ﻟﻠﻤﺒ ـﺮﻣﺠﻴﻦ- وذﻟ ـﻚ ﺑﺴ ـﺒﺐ ﺿ ـﻌﻒ ﺗﻌﺎﻣﻠ ـﻪ ﻣ ـﻊ اﻟﻤﺆﺷ ـﺮات‬
                                         ‫ـ‬            ‫ـ‬       ‫ـ‬         ‫ـ‬     ‫ـ‬
‫‪ ،Pointers‬و ﻋﻨﺪ اﻟﺤﺪﻳﺚ ﻋﻦ اﻟﻤﺸﺎرﻳﻊ اﻟﻌﻤﻼﻗﺔ، ﻓﻄﺎﻗـﺔ ‪ Visual Basic‬ﻻ ﺗﺴـﺘﻮﻋﺐ‬
‫اآﻮاد ﺣﺠﻤﻬﺎ اآﺜﺮ ﻣـﻦ 46‪ K‬ﻓـﻲ ﻧﺎﻓـﺬة ﻧﻤـﻮذج واﺣـﺪة او اﺟـﺮاء واﺣـﺪ، وهـﺬا اﻟﻘﺼـﻮر‬
‫ﻳﻜﻔﻲ ان ﻳﺠﻌﻞ ‪ Visual Basic‬اﺳﻮأ ﻣﻨﺼـﺔ ﺗﻄـﻮﻳﺮ اﻟﺘﻄﺒﻴﻘـﺎت ﻓـﻲ ﻧﻈـﺮ ﺁﻻف –ان ﻟـﻢ‬
                                           ‫ﻳﻜﻦ ﻣﻼﻳﻴﻦ- اﻟﻤﺒﺮﻣﺠﻴﻦ ﺣﻮل اﻟﻌﺎﻟﻢ اﻳﻀﺎ!‬
‫إﻻ ان اﻟﻤﺒﺮﻣﺠﻴﻦ اﻟﻤﻮاﻟﻴﻦ ﻟــ ‪ Visual Basic‬ﻗـﺪﻣﻮا ﻋﺸـﺮات اﻟﺤﻠـﻮل ﻟﻤﺤﺎوﻟـﺔ ﺗﻐﻄﻴـﺔ‬
‫واﻻﻟﺘﻔﺎف ﺣﻮل ﻗﺼﻮر اﻟﻠﻐﺔ ﻓﻲ اﻟﻘﻀـﺎﻳﺎ اﻟﺴـﺎﺑﻘﺔ، واﻟﻤﺒـﺮﻣﺠﻴﻦ اﻟﻤﻌـﺎدﻳﻦ ﻟــ ‪Visual‬‬
‫‪ Basic‬اﺛﺒﺘﻮا ان ﺗﻠﻚ اﻟﺤﻠﻮل ﻗﺪ أﻋﻤﺖ اﻟﻘﺼـﻮر ﺑـﺪﻻ ﻣـﻦ ﺗﻜﺤﻴﻠﻬـﺎ، ﻓﻬـﻲ ﻗـﺪ اﺿـﻌﻔﺖ‬
                                                  ‫آﻔﺎءة اﻟﺘﻨﻔﻴﺬ وزادت اﻻآﻮاد ﺗﻌﻘﻴﺪا.‬
                                                    ‫ج‬


‫اﻣﺎ اﻟﻤﺒﺮﻣﺠﻴﻦ اﻟﻤﺤﺎﻳﺪﻳﻦ –واﻟﻤﺆﻟﻒ ﺑﻴﻦ ﺻﻔﻮﻓﻬﻢ- ﻳﻘﻮﻟﻮن ﻟﻚ ﺑﻜـﻞ اﺧﺘﺼـﺎر: اذا آـﺎن‬
‫‪ Visual Basic‬ﻳﻘﺪم ﻟﻚ ﺣﻠﻮل ﻟﻤﺸﺎآﻠﻚ، ﻓﻜﻦ ﻣﺒﺮﻣﺞ ‪ ،Visual Basic‬واذا آﺎن ‪Visual‬‬
                   ‫‪ Basic‬ﻻ ﻳﻘﺪم ﻟﻚ ﺣﻠﻮل ﻟﻤﺸﺎآﻠﻚ، ﻓﻼ ﺗﻜﻦ ﻣﺒﺮﻣﺞ ‪.Visual Basic‬‬
‫وﻣﻦ ﻣﻨﻄﻠﻖ اﻟﻤﺤﺎﻳﺪة، اﻗﺪم ﻟﻚ هﺬا اﻟﻜﺘﺎب ﻟﻴﺸﺮح ﻟـﻚ اﻟﺒﺮﻣﺠـﺔ ﺑﺎﺳـﺘﺨﺪام ‪Visual‬‬
‫‪ Basic‬وﻟﻦ اﺗﻌﺪى هـﺬا اﻟﻨﻄـﺎق اﺑـﺪا، ﻓـﻼ ﺗﺘﻮﻗـﻊ ﻓﺼـﻮل –ﻣﻀـﻴﻌﺔ ﻟﻠﻮﻗـﺖ- ﺗﻘـﺎرن ﻟـﻚ‬
‫‪ Visual Basic‬ﻣﻊ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ اﻻﺧﺮى، او ﻣﺎدﺣﺔ ‪ Visual Basic‬آﻠﻐـﺔ ﺑﺮﻣﺠـﺔ اﻟﻌﻘـﺪ‬
‫اﻻﺧﻴـﺮ، او ﻣﻈﻬـﺮة ﻋﻴـﻮب ‪ Visual Basic‬ﺣﺘـﻰ ﺗﺸـﻮﻩ ﺳـﻤﻌﺘﻪ. ﻓﻬـﺬا اﻟﻜﺘـﺎب ﻳﺤـﺎول‬
‫ﺗﺸﻴﻴﺪ ﺑﻨﻴﺔ ﻗﻮﻳﺔ ﻟﻚ ﺣﺘﻰ ﺗﻤﻜﻨﻚ ﻣﻦ اﻻﻧﻄﻼق ﻓﻲ ﺑﺮﻣﺠﺔ ‪ Visual Basic‬ﻣـﻦ اوﺳـﻊ‬
                                                                          ‫اﺑﻮاﺑﻪ.‬

                                                                 ‫ﻟﻤﻦ هﺬا اﻟﻜﺘﺎب؟‬
‫اذا آﻨﺖ ﺟﺎد ﻓﻲ ان ﺗﻜﻮن ﻣﺒﺮﻣﺞ ‪ ،Visual Basic‬ﻓﻬﺬا اﻟﻜﺘﺎب ﻳﺒﻨـﻲ ﻟـﻚ ﻗﺎﻋـﺪة ﻗﻮﻳـﺔ‬
‫ﺗﺴﺘﻨﺪ ﻋﻠﻴﻬﺎ ﺣﺘﻰ ﺗﺘﻤﻜﻦ ﻣﻦ ﻣﻮاﺟﻬﺔ اﻻآـﻮاد اﻟﻤﻨﺘﺸـﺮة هﻨـﺎ وهﻨـﺎك ﺑـﻴﻦ اﻟﻤﺼـﺎدر‬
‫اﻟﻤﺨﺘﻠﻔﺔ اﻟﻤﺘﻌﻠﻘﺔ ﺑـ ‪ Visual Basic‬آﻤﻮاﻗﻊ اﻻﻧﺘﺮﻧﺖ، ﻣﻜﺘﺒﺔ ‪ MSDN‬او آﺘـﺐ ﻣﺘﻘﺪﻣـﺔ‬
‫اﺧﺮى. اﻣﺎ اذا آﻨﺖ ﻧﺎﻗﺪ –ﻏﻴﺮ هﺎدف- او ﺗﺮﻏﺐ ﻓـﻲ اﻟﺤﺼـﻮل ﻋﻠـﻰ ﺛﻘﺎﻓـﺔ ﺑﺮﻣﺠﻴـﺔ ﻻ‬
‫ﺗﻘﺪم وﻻ ﺗﺆﺧﺮ، ﻓﻴﻜﻔـﻲ ﻣـﺎ ﻗﺮأﺗـﻪ ﻣـﻦ اﻟﺼـﻔﺤﺎت اﻟﺴـﺎﺑﻘﺔ ﻻن اﻟﻜﺘـﺎب ﻻ اﻋﺘﻘـﺪ اﻧـﻪ‬
                                                                               ‫ﻣﻨﺎﺳﺐ ﻟﻚ.‬
‫هﺬا اﻟﻜﺘﺎب ﻣﺨﺘﺺ ﻓﻲ ‪ Visual Basic‬ﻓﻘﻂ وﻟﻴﺲ اﻟﺒﺮﻣﺠﺔ ﺑﺸﻜﻞ ﻋـﺎم، ﻓﻠـﻦ اﺗﻄـﺮق‬
 ‫ـ ـ‬          ‫ـ‬        ‫ـ‬       ‫ـ‬
‫اﻟ ـﻰ ﻣﻮاﺿ ـﻴﻊ وﺗﻌ ـﺎرﻳﻒ ﻃﻮﻳﻠ ـﺔ آ ــ ﻣ ـﺎهﻮ اﻟﺒﺮﻧ ـﺎﻣﺞ؟، ﻣ ـﺎهﻲ ﻟﻐ ـﺔ اﻟﺒﺮﻣﺠ ـﺔ؟، ﻣ ـﺎ ه ـﻮ‬
                                        ‫ـ‬          ‫ـ ـ ـ‬                ‫ـ‬       ‫ـ‬       ‫ـ‬
         ‫اﻟﺨﻮارزم؟ .... اﻟﺦ. ﻣﻊ ذﻟﻚ، ﻓﻬﻮ ﻣﻮﺟﻪ اﻟﻰ آﺂﻓﺔ اﻟﻤﺴﺘﻮﻳﺎت ﻟﻼﺳﺒﺎب اﻟﺘﺎﻟﻴﺔ:‬

‫ﻟﻠﻤﺒﺘﺪﺋﻴﻦ: ﻓﻬﻮ ﻳﻌﺮﻓﻬﻢ ﻋﻠـﻰ ‪ Visual Basic‬وﺑﻴﺌـﺔ اﻟﺘﻄـﻮﻳﺮ اﻟﻤﺘﻜﺎﻣﻠـﺔ اﻟﺨﺎﺻـﺔ ﺑـﻪ،‬
    ‫ـ‬      ‫ـ‬                      ‫ـ‬           ‫ـ‬                  ‫ـ‬
‫وﻳﺸـﺮح ﻟﻬـﻢ آـﻞ ﻣـﺎ ﻳﺤﺘﺎﺟﻮﻧـﻪ ﻟﻠﺒﺮﻣﺠـﺔ اﻟﻔﻌﻠﻴـﺔ ﺑــ ‪ Visual Basic‬آﺸـﺮح اﻟﻨﻤـﺎذج‬
‫واﻻدوات، ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ ‪ ،BASIC‬ﺣﻠﻮل ﻟﻤﺸﺎآﻠﻬﻢ اﻟﻴﻮﻣﻴـﺔ وزﻳـﺎدة ﺛﻘـﺎﻓﺘﻬﻢ اﻟﺒﺮﻣﺠﻴـﺔ‬
               ‫ﺑﺘﻘﺪﻳﻢ ﻣﻔﻬﻮم اﻟﺒﺮﻣﺠﺔ آﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ ‪ OOP‬وﺗﻄﺒﻴﻘﻬﺎ ﺑـ ‪.Visual Basic‬‬
‫ﻟﻠﻤﺘﻮﺳﻄﻴﻦ: ﻓﻬﻮ ﻳﺤﻘﻖ ﻟﻬﻢ ﻗﻔـﺰة ﻧﻮﻋﻴـﺔ اﻟـﻰ ﻣﻮاﺿـﻴﻊ ﻣﺘﻘﺪﻣـﺔ آﺒﺮﻣﺠـﺔ ﻗﻮاﻋـﺪ‬
‫اﻟﺒﻴﺎﻧــﺎت ‪ ،DataBases‬ﺗﻄﺒﻴﻘــﺎت ﻣﺘﻘﺪﻣــﺔ ﻋﻠــﻰ اﻟﻨﻤــﺎذج، ﻗﻀــﺎﻳﺎ ﺣــﻮل اﺟــﺮاءات ‪API‬‬
                                    ‫وﺑﺮﻣﺠﺔ اﻟﻤﻜﻮﻧﺎت ‪ COM‬واﻟﻤﻜﻮﻧﺎت اﻟﻤﻮزﻋﺔ ‪.DCOM‬‬
‫ﻟﻠﻤﺘﻘﺪﻣﻴﻦ: هﺬا اﻟﻜﺘﺎب ﻻﻳﻘﺪم ﻟﻠﻤﺘﻘﺪﻣﻴﻦ ﺳﻮى اﻋـﺎدة اﻧﻌـﺎش ‪ Refresh‬ذاآـﺮﺗﻬﻢ‬
‫ﻟﻤﻮاﺿﻴﻊ ﺑﺮﻣﺠﻴﺔ ﺧﺎﺻﺔ ﺑـ ‪ ،Visual Basic‬واﻟﺴﺒﺐ اﻟﺬي ﻳﺠﻌﻞ هﺬا اﻟﻜﺘﺎب ﻣﻮﺟﻪ ﻟﻬﻢ‬
‫ﻻ ﻳﻌﺪو ان ﻳﻜﻮن اﻻ ﺳﺒﺐ ﺷﺨﺼﻲ ﻟﻠﻤﺆﻟﻒ، وهﻲ زﻳﺎدة اﻟﺜﻘﺔ ﺑﻨﻔﺴﻪ ﻋﻨﺪﻣﺎ ﻳﻌﻠﻢ ان‬
                             ‫ﻣﺒﺮﻣﺠﻲ ‪ Visual Basic‬اﻟﻤﺘﻘﺪﻣﻴﻦ ﻗﺪ اﻋﺤﺒﻮا ﻓﻲ آﺘﺎﺑﻪ.‬
                                                ‫د‬


‫ﻧﻘﻄﺔ اﺧﺮى اود ﺗﻮﺿﻴﺤﻬﺎ هﻲ ان هـﺬا اﻟﻜﺘـﺎب ﻟـﻴﺲ ﻣﺮﺟـﻊ ‪ Reference‬ﻣـﻦ ﻣﺮاﺟـﻊ‬
‫‪ MSDN‬ﺗﺮﺟﻢ اﻟﻰ اﻟﻠﻐﺔ اﻟﻌﺮﺑﻴﺔ. ﻓـﻼ ﺗﺘﻮﻗـﻊ ان اﻗـﻮم ﺑﺸـﺮح ﺟﻤﻴـﻊ اﻟﺜﻮاﺑـﺖ، اﻟـﺪوال،‬
‫اﻟﻜﺎﺋﻨﺎت .... اﻟﺦ ﺷﺮﺣﺎ ﺗﻔﺼﻴﻠﻴﺎ، وذﻟﻚ ﻻﻧﻨﻲ ارﻳﺪ ان اﻧﺘﻬﻲ ﻣﻦ آﺘﺎﺑﺔ اﻟﻜﺘﺎب ﻗﺒـﻞ ان‬
      ‫ـ‬             ‫ـ‬     ‫ـ‬    ‫ـ‬
‫ﺗﺸـﻴﺐ ﺷـﻌﺮات رأﺳـﻲ. ﻣـﻊ ذﻟ ـﻚ، ﺗﻌﺮﺿـﺖ –ﺑﺎﺧﺘﺼـﺎر- ﻟﻤﺌـﺎت اﻟـﺪوال، اﻟﺨﺼ ـﺎﺋﺺ،‬
                                           ‫ـ‬        ‫ـ‬  ‫ـ‬     ‫ـ‬           ‫ـ‬       ‫ـ‬
‫اﻟﻜﺎﺋﻨﺎت .... اﻟﺦ ﺑﻴﻦ ﺻﻔﺤﺎت هﺬا اﻟﻜﺘﺎب. ﻟﺬﻟﻚ، ارﺟﻮ ﻣﻨﻚ اﻟﺤﺼﻮل ﻓﻲ اﻗـﺮب ﻓﺮﺻـﺔ‬
‫ﻋﻠﻰ ﻧﺴﺨﺔ ﻣﻦ اﺳﻄﻮاﻧﺔ ﻣﻜﺘﺒﺔ ‪ MSDN‬ﻟﻠﺤﺼـﻮل ﻋﻠـﻰ اﻟﺘﻌﻠﻴﻤـﺎت اﻟﻔﻮرﻳـﺔ واﻟـﺪﻋﻢ‬
‫اﻟﻔﻨﻲ اﻟﻼزم ﻟﻠﺘﻮﻏﻞ ﻓﻲ ﺗﻔﺎﺻﻴﻞ ﺟﻤﻴﻊ اﻟﺪوال، اﻟﻜﺎﺋﻨﺎت واﻋﻀـﺎﺋﻬﺎ، اﻟﺜﻮاﺑـﺖ .... اﻟـﺦ‬
                                                          ‫ﻗﺒﻞ ان ﺗﺒﺪأ ﺑﻘﺮاءة اﻟﻜﺘﺎب.‬

                                           ‫ﻣﺎذا ﻋﻦ ‪Visual Basic.NET‬؟‬
‫ﻳﺒــﺪو ان اﻟﺤــﺮوف ‪ .NET‬ﺗﺸــﺪ اﻧﺘﺒــﺎﻩ اﻟﻤﺒــﺮﻣﺠﻴﻦ ﺑﻌــﺪﻣﺎ وزﻋــﺖ ‪ Microsoft‬اﻟﻨﺴــﺦ‬
‫اﻟﺘﺠﺮﻳﺒﻴﺔ ‪ Beta‬ﻣـﻦ ﺟﻤﻴـﻊ اﻋﻀـﺎء ‪ .Visual Studio.NET‬ﺣﺴـﻨﺎ، اﻻﺻـﺪار اﻻﺧﻴـﺮ ﻣـﻦ‬
‫‪ Visual Basic‬هﻮ اﻻﺻﺪار اﻟﺴﺎدس 6‪ VB‬واﻟﺬي ﻳﻤﺜﻞ ﻧﻬﺎﻳﺔ اﻻﺳـﻄﻮرة ‪،Visual Basic‬‬
‫اﻣﺎ ‪ Visual Basic.NET‬ﻓﻬﻲ ﻟﻐﺔ ﺑﺮﻣﺠﺔ ﺟﺪﻳﺪة ﻻ ﻳﻜﻤﻦ اﻟﺸﺒﻪ ﺑﻴﻨﻬﺎ وﺑﻴﻦ اﺳـﻄﻮرﺗﻨﺎ‬
                        ‫ـ‬      ‫ـ‬       ‫ـ‬               ‫ـ‬
‫إﻻ اﻻﺳـﻢ ‪ Visual Basic‬وﺻـﻴﻎ ‪ Syntax‬ﺑﻌـﺾ اﻻواﻣـﺮ. ﻓﺎﻻﺳـﻢ ‪Visual Basic.NET‬‬   ‫ـ‬
‫ﻟﻴﺲ ﺳﻮى ﻟﻌﺒﺔ ﺗﺴﻮﻳﻘﻴﺔ ﻗﺎﻣﺖ ﺑﻬـﺎ ‪ Microsoft‬ﺣﺘـﻰ ﻻ ﺗﺨﺴـﺮ ﺟﻤﻴـﻊ زﺑﺎﺋﻨﻬـﺎ ﻣـﻦ‬
‫ﻣﺒﺮﻣﺠــﻲ 1‪ VB‬ﺣﺘــﻰ 6‪ .VB‬ﻓﻘﺒــﻞ ان ﺗﺸــﺪ اﻟﺮﺣــﺎل اﻟــﻰ ‪ ،Visual Basic.NET‬ﻓﻜــﺮ‬
‫ﺑﺎﻟﻤﻮﺿﻮع ﺟﻴﺪا ﻻن ﺷﺪ اﻟﺮﺣﺎل ﺳﻴﻜﻮن اﻻﻧﺘﻘﺎل اﻟﻰ ﻟﻐـﺔ ﺑﺮﻣﺠـﺔ ﺟﺪﻳـﺪة، آﺎﻻﻧﺘﻘـﺎل‬
‫ﻣﻦ 6‪ VB‬اﻟـﻰ #‪ .C‬ارﺟـﻮ ان ﻻ ﺗﻌﺘﻘـﺪ اﻧﻨـﻲ ارﻓـﺾ ‪ ،Visual Basic.NET‬ﺑـﻞ ﺳـﺄﻋﻴﺪ‬
‫آﺘﺎﺑﺔ اﻟﺠﻤﻠﺔ اﻟﺤﻴﺎدﻳﺔ اﻟﺘﻲ ذآﺮﺗﻬﺎ ﻓﻲ اﻟﻤﻘﺪﻣﺔ ﻣﻊ اﺿﺎﻓﺔ 21 ﺣﺮﻓـﺎ وارﺑـﻊ ﻧﻘـﺎط: اذا‬
‫آﺎن ‪ Visual Basic.NET‬ﻳﻘﺪم ﻟﻚ ﺣﻠﻮل ﻟﻤﺸﺎآﻠﻚ، ﻓﻜـﻦ ﻣﺒـﺮﻣﺞ ‪،Visual Basic.NET‬‬
‫واذا آﺎن ‪ Visual Basic.NET‬ﻻ ﻳﻘﺪم ﻟﻚ ﺣﻠـﻮل ﻟﻤﺸـﺎآﻠﻚ، ﻓـﻼ ﺗﻜـﻦ ﻣﺒـﺮﻣﺞ ‪Visual‬‬
                                                                        ‫‪.Basic.NET‬‬
‫اذا آﻨﺖ ﺳﺘﺴﺘﻤﺮ ﻋﻠﻰ اﺣﺪث اﻻﺻﺪارات 6‪ ،VB‬ﻓﺴﻴﻜﻮن اﻟﻜﺘﺎب ﻣﻨﺎﺳﺐ ﺑﺘﻘﺪﻳﺮ ﺟﻴﺪ‬
‫ﺟﺪا، اﻣﺎ اذا آﻨﺖ ﻗﺪ ﻓﺮﻏﺖ ﻣﺴﺎﺣﺔ ﻓﻲ ﻗﺮﺻـﻚ اﻟﺼـﻠﺐ ‪ HardDisk‬ﻟﺘﻨﺼـﻴﺐ ‪Visual‬‬
‫‪ Basic.NET‬ﻋﻠﻴﻬﺎ، ﻓﻘﺪ ﻳﻜﻮن اﻟﻜﺘـﺎب ﻣﻨﺎﺳـﺐ ﺑﺘﻘـﺪﻳﺮ ﻣﻘﺒـﻮل ﻣﺮﺗﻔـﻊ او ﺟﻴـﺪ –ﻋﻠـﻰ‬
‫اﻻآﺜﺮ، ﻻن اﻟﻔﺎﺋﺪة ﺳﺘﻜﻮن ﻧﻈﺮﻳﺔ وﻟﻴﺲ ﻋﻤﻠﻴﺔ، ﻓﺴﻴﺘﻄﺮق هـﺬا اﻟﻜﺘـﺎب اﻟـﻰ ﺑﻌـﺾ‬
‫اﻟﻤﻮاﺿﻴﻊ اﻟﺘﻲ ﻗﺪ ﺗﻔﻴﺪك –ﻧﻈﺮﻳﺎ- ﻓﻲ ﻟﻐﺘﻚ اﻟﺠﺪﻳـﺪة آﺎﻟﺒﺮﻣﺠـﺔ آﺎﺋﻨﻴـﺔ اﻟﺘﻮﺟـﻪ ‪OOP‬‬
‫واﻟﺘﻄﺒﻴﻘــﺎت ﻣﺘﻌــﺪدة اﻟﻄﺒﻘــﺎت ‪ nTied Applications‬واﻟﻤﻜﻮﻧــﺎت اﻟﻤﻮزﻋــﺔ ‪DCOM‬‬
                                                         ‫واﻟﻘﻠﻴﻞ ﻣﻦ ﻗﻮاﻋﺪ اﻟﺒﻴﺎﻧﺎت.‬
                                                   ‫ﻩ‬


                                                                  ‫ﻣﻮاﺿﻴﻊ اﻟﻜﺘﺎب‬
‫ﺻﻔﺤﺔ اﻟﻤﺤﺘﻮﻳﺎت اﻋﻄﺘﻚ ﻓﻜﺮة ﻋﺎﻣﺔ ﻋﻦ ﻣﻮاﺿﻴﻊ اﻟﻜﺘﺎب، وهﻨﺎ اﻋﻄﻴﻚ ﻣﻠﺨﺺ ﻻﺟﺰاء‬
                                                          ‫اﻟﻜﺘﺎب اﻻرﺑﻌﺔ:‬

                                                           ‫اﻟﺠﺰء اﻻول: اﻻﺳﺎﺳﻴﺎت‬
‫اﻟﻐﺮض واﺿﺢ ﻣﻦ ﻋﻨﻮان اﻟﺠﺰء، ﻓﻬـﻮ ﻳﺒـﺪأ ﺑﺘﻌﺮﻳﻔـﻚ ﻋﻠـﻰ ﺑﻴﺌـﺔ اﻟﺘﻄـﻮﻳﺮ اﻟﻤﺘﻜﺎﻣﻠـﺔ ﻟــ‬
‫‪ Visual Basic‬ﻣﻊ آﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺠﻚ اﻻول، ﺛﻢ ﻳﺒﺪأ ﺑﺎﻟﺘﺤﺪث ﻋﻦ اﻟﻨﻤﺎذج واﻻدوات وﺷـﺮح‬
‫ﺟﻤﻴﻊ ﺧﺼﺎﺋﺼﻬﺎ، ﻃﺮﻗﻬﺎ واﺣﺪاﺛﻬﺎ، ﺛﻢ ﻳﻘﻮى ﻣﻬﺎراﺗﻚ اﻟﺒﺮﻣﺠﻴﺔ ﺳـﻮاء آﺎﻧـﺖ ﻓـﻲ ﻟﻐـﺔ‬
‫اﻟﺒﺮﻣﺠﺔ ‪ BASIC‬او وﻇﺎﺋﻒ ﻣﻜﺘﺒـﺎت ‪ VB‬و ‪ .VBA‬اﻟﻤﺰﻳـﺪ اﻳﻀـﺎ، ﻳﻨﻘﻠـﻚ هـﺬا اﻟﺠـﺰء اﻟـﻰ‬
‫اﻟﻤﺮﺣﻠــﺔ اﻟﺜﺎﻧﻴــﺔ وهــﻲ اﻟﺒﺮﻣﺠــﺔ آﺎﺋﻨﻴــﺔ اﻟﺘﻮﺟــﻪ ‪ OOP‬ﻣــﻊ ﺗﻔﺼــﻴﻞ ﻣﺒﺎدﺋﻬــﺎ اﻟــﺜﻼث:‬
       ‫اﻟﺘﻐﻠﻴﻒ ‪ ،Encapsulation‬ﺗﻌﺪد اﻟﻮاﺟﻬﺎت ‪ Polymorphism‬واﻟﻮراﺛﺔ ‪.Inheritance‬‬

                                        ‫اﻟﺠﺰء اﻟﺜﺎﻧﻲ: ﺑﺮﻣﺠﺔ ﻗﻮاﻋﺪ اﻟﺒﻴﺎﻧﺎت‬
 ‫ـ‬      ‫ـ‬     ‫ـ‬          ‫ـ‬
‫ﻳﻌﺘﺒـﺮ هـﺬا اﻟﺠـﺰء اﻟﻤـﺪﺧﻞ اﻟـﺮﺋﻴﺲ اﻟـﻰ ﺑﺮﻣﺠـﺔ اﻟﺘﻄﺒﻴﻘـﺎت اﻟﻤﻌﺘﻤـﺪة ﻋﻠـﻰ ﻗﻮاﻋـﺪ‬
                                  ‫ـ‬      ‫ـ‬         ‫ـ‬       ‫ـ‬     ‫ـ‬     ‫ـ ـ‬
‫اﻟﺒﻴﺎﻧﺎت ‪ DataBases‬ﺣﻴﺚ ﻳﺒﺪأ ﺑﺎﺳﺎﺳﻴﺎت ﻃﺮق اﻟﻮﺻﻮل اﻟـﻰ اﻟﺒﻴﺎﻧـﺎت ‪Data Access‬‬
‫وﻣﻘﺮر ﺳﺮﻳﻊ ﻓﻲ ﻟﻐﺔ اﻻﺳﺘﻌﻼم ‪ ،SQL‬آﻤﺎ ﻳﺨﺘﺺ آﺎﺋﻨﺎت ‪ ADO‬وﻳﺘﻮﻏﻞ ﻓﻲ ﺗﻔﺎﺻـﻴﻞ‬
                                            ‫ﺑﻌﺾ ادوات اﻟﺠﺪاول واﻧﺸﺎء اﻟﺘﻘﺎرﻳﺮ.‬

                                               ‫اﻟﺠﺰء اﻟﺜﺎﻟﺚ: ﻣﻮاﺿﻴﻊ ﻣﺘﻘﺪﻣﺔ‬
‫ﻻ ﺗﻨﺘﻘﻞ اﻟﻰ هﺬا اﻟﺠﺰء ﺣﺘﻰ ﺗﻜﻮن ﻗﺪ اﺳـﺘﻮﻋﺒﺖ اﻟﺠـﺰء اﻻول ﺑﺸـﻜﻞ ﺟﻴـﺪ، ﻓـﺎﻟﺠﺰء‬
‫ﻳﺘﻌﺪى اﻓﺎق ‪ Visual Basic‬اﻟﻰ ان ﻳﺼﻞ اﻟﻰ اﻟﺒﺮﻣﺠﺔ ﺑﺎﺳﺘﺨﺪام اﺟﺮاءات ‪ API‬وﻋـﺮض‬
‫ﺗﻄﺒﻴﻘﺎت ﻋﻤﻠﻴﺔ ﺗﺆدي اﻟﻰ زﻳﺎدة ﻓﺎﻋﻠﻴـﺔ وﻣﺮوﻧـﺔ ﺑﺮاﻣﺠـﻚ، آﻤـﺎ ﻳﺤﺘـﻮي ﻋﻠـﻰ ﻓﺼـﻞ‬
‫ﺑﻌﻨﻮان "اﻻﺳﺘﺨﺪام اﻟﻤﺘﻘﺪم ﻟﻠﻨﻤﺎذج" ﺣﻴـﺚ ﻳﻈﻬـﺮ ﻟـﻚ اﻣﻜﺎﻧﻴـﺎت اﻟﻨﻤـﺎذج ﺑﻄـﺮق ﻟـﻢ‬
 ‫ـ‬                        ‫ـ‬                              ‫ـ‬
‫ﺗﺨﻄـﺮ ﻋﻠـﻰ ﺑﺎﻟـﻚ. واﺧـﺘﻢ اﻟﺠـﺰء ﺑﻔﺼـﻠﻴﻦ ﻟﺒﺮﻣﺠـﺔ اﻟﻜﺎﺋﻨـﺎت اﻟﻤﺮآﺒـﺔ ‪ COM‬وآـﻞ ﻣـﺎ‬
‫ﺗﺤﺘﺎﺟﻪ ﻟﺘﻄـﻮﻳﺮ ﻣﺸـﺎرﻳﻊ ﻣـﻦ ﻧـﻮع ‪ ActiveX DLL ،ActiveX EXE‬و ‪ ActiveX OCX‬ﻣـﻊ‬
                                           ‫ﻣﻘﺪﻣﺔ اﻟﻰ اﻟﻤﻜﻮﻧﺎت اﻟﻤﻮزﻋﺔ ‪.DCOM‬‬

                                                     ‫اﻟﺠﺰء اﻟﺮاﺑﻊ: ﺑﺮﻣﺠﺔ اﻻﻧﺘﺮﻧﺖ‬
‫وهﻮ اﺻﻐﺮ اﺟﺰاء هﺬا اﻟﻜﺘﺎب، ﻓﻬﻮ ﻳﺤﺘﻮي ﻋﻠﻰ ﻓﺼﻠﻴﻦ اﻻول ﻳﺨﺘﺺ ﺑﺒﺮﻣﺠـﺔ ﺻـﻔﺤﺎت‬
‫‪ DHTML‬اﻟﺪﻳﻨﺎﻣﻴﻜﻴﺔ وﻣﻘﺪﻣﺔ اﻟﻰ اﻟﻠﻐﺔ اﻟﺼﻐﻴﺮة ‪ ،VBScript‬واﻟﻔﺼﻞ اﻻﺧﺮ ﻳﻨﻘﻠﻚ ﻣـﻦ‬
‫ﺑﺮﻣﺠــﺔ اﻟﻌﻤﻴــﻞ ‪ Client‬اﻟــﻰ ﺑﺮﻣﺠــﺔ اﻟﺨــﺎدم ‪ Server‬ﺑﺎﺳــﺘﺨﺪام اﻟﺨــﺎدم ‪ IIS‬ﻟﺘﻄــﻮﻳﺮ‬
                                                                       ‫ﺻﻔﺤﺎت ‪.ASP‬‬
                                                     ‫و‬


                                                            ‫ﻃﺮﻳﻘﺔ ﺗﻨﻈﻴﻢ اﻟﻜﺘﺎب‬
    ‫ـ‬        ‫ـ‬       ‫ـ‬          ‫ـ‬
‫ﻟـﻢ اﺳ ـﺘﺨﺪم ﺳـﻮى اﻟﻄ ـﺮق اﻟﺘﻘﻠﻴﺪﻳ ـﺔ ﻟﺘﻨﻈـﻴﻢ وﺗﻨﺴ ـﻴﻖ ﻣﺤﺘﻮﻳـﺎت اﻟﻜﺘ ـﺎب. ﻓﻀ ـﻠﺖ‬
                                        ‫ـ‬      ‫ـ‬          ‫ـ‬      ‫ـ‬       ‫ـ‬     ‫ـ‬
‫اﺳــﺘﺨﺪام اﻟﺨــﻂ ‪ Tahoma‬ﻟﻮﺿــﻮﺣﻪ ودﻋﻤــﻪ ﻓــﻲ ﺟﻤﻴــﻊ اﻻﺟﻬــﺰة ﻓﻬــﻮ ﻣــﻦ اﻟﻨــﻮع‬
‫‪ ،UNICODE‬وهﻮ ﻧﻔﺲ اﻟﺨﻂ اﻟﻤﺴﺘﺨﺪم ﻓﻲ آﺘﺎﺑﺔ اﻻآﻮاد، واﻟﺤﺪﻳﺚ ﻋﻦ اﻻآﻮاد ﻓـﻲ‬
‫هﺬا اﻟﻜﺘﺎب ﻳﺠﺮﻧﻲ اﻟﻰ اﺧﺒﺎرك اﻧﻚ ﻟﻦ ﺗﺠﺪ اﻻآﻮاد اﻟﻤﺴﺘﺨﺪﻣﻪ ﻓﻲ اﻻﻣﺜﻠـﺔ اﻻ ﺑـﻴﻦ‬
‫ﺻﻔﺤﺎت هﺬا اﻟﻜﺘﺎب، اﻣﺎ ﺑﻌﺾ اﻻﻣﺜﻠﺔ اﻟﻄﻮﻳﻠﺔ او اﻟﺘﻲ ﺗﺘﻄﻠﺐ ﻣﻠﻔﺎت ﻣﺘﻌﺪدة ﻟﺘﻮﺿﻴﺢ‬
‫ﻓﻜﺮﺗﻬﺎ، ﻓﺎﻟﺮﻣﺰ ﺳﻴﻈﻬﺮ ﻓﻲ اﻋﻠﻰ اﻟﻜﻮد ﻣﻮﺿﺤﺎ ان اﻟﻜﻮد اﻟﺘﺎﻟﻲ ﻣﻮﺟﻮد ﻓﻲ داﺧـﻞ‬
‫اﻟﻤﻠﻒ اﻟﻤﻀـﻐﻮط ‪ Codes.ZIP‬واﻟـﺬي ﺗﺴـﺘﻄﻴﻊ اﻧﺰاﻟـﻪ ‪ Download‬ﻣـﻦ ﻧﻔـﺲ اﻟﻤﻮﻗـﻊ‬
‫اﻟﺬي اﻧﺰﻟﺖ اﻟﻜﺘﺎب ﻣﻨﻪ. ﺳﺘﻼﺣﻆ اﻳﻀﺎ اﻧﻨﻲ اﺳﺘﺨﺪم اﻻﻗـﻮاس ] و [ اذا ﻗﺼـﺪت ازرار‬
‫ﻓﻲ ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﻴﺢ آـ ]‪... [ESC] ،[ENTER‬اﻟﺦ. وﺑﺎﻟﻨﺴـﺒﺔ ﻟﻼﺷـﻜﺎل اﻟﺘﻮﺿـﻴﺤﻴﺔ، ﻟـﻢ‬
‫اآﺜﺮ ﻣﻦ اﺳﺘﺨﺪاﻣﻬﺎ ﺧﺸﻴﺔ ازدﻳﺎد ﻣﺴﺎﺣﺔ ﻣﻠﻒ اﻟﻜﺘﺎب -واﻟﺬي ﻗﺪ اﻓﺼﻞ اﺟﺰاءﻩ اﻟﻰ‬
‫ﻣﻠﻔﺎت ﻣﺴﺘﻘﻠﺔ رﻏﻢ اﻧﻨﻲ ﻻ اﺣﺒﺬ ذﻟـﻚ، واﻻﺳـﻠﻮب اﻟﻤﻌﺘﻤـﺪ ﻟﺘـﺮﻗﻴﻢ اﻻﺷـﻜﺎل ﻳﺒـﺪأ‬
‫ﺑﺮﻗﻢ اﻟﻔﺼﻞ ﺛﻢ رﻗﻢ اﻟﺸﻜﻞ ﺑﺬﻟﻚ اﻟﻔﺼﻞ، ﻓﻼ اﻋﺘﻘﺪ اﻧـﻚ ﺗﺮﻳـﺪ اﻟﺒﺤـﺚ ﻋـﻦ اﻟﺸـﻜﻞ‬
                                                                    ‫8395849 !‬

                                                                           ‫آﻠﻤﺔ اﺧﻴﺮة‬
‫ﺑﺎﻻﻋﺘﻤﺎد ﻋﻠﻰ ﻣﺠﻬـﻮدي، ﻓﺎﻧـﻪ ﻳﺴـﺘﺤﻴﻞ ﻋﻠـﻲ آﺘﺎﺑـﺔ وﻟـﻮ ﺣـﺮف واﺣـﺪ ﻣـﻦ ﺣـﺮوف‬
‫اﻟﻜﺘﺎب ان ﻟﻢ ﻳﻜﺘﺐ اﷲ ﺳﺒﺤﺎﻧﻪ وﺗﻌﺎﻟﻰ اﻟﺘﻮﻓﻴﻖ اوﻻ واﺧﻴﺮا ﻻﺗﻤﺎﻣﻪ. ﻣـﺎ اود ان اﻗﻮﻟـﻪ‬
  ‫ـ ـ‬           ‫ـ‬        ‫ـ‬       ‫ـ‬    ‫ـ‬
‫ﻟ ـﻚ ﻋﺰﻳ ـﺰي اﻟﻘ ـﺎرئ، ان اﻟﻜﺘ ـﺎب اﻟ ـﺬي اﻣ ـﺎم ﻋﻴﻨﻴ ـﻚ ﻗ ـﺪ آﻠﻔﻨ ـﻲ اﻟﻜﺜﻴ ـﺮ واﻟﻜﺜﻴ ـﺮ ﻣ ـﻦ‬
                                               ‫ـ‬      ‫ـ‬      ‫ـ‬             ‫ـ‬       ‫ـ‬      ‫ـ‬
‫اﻟﻤﺠﻬﻮد اﻟﻌﻘﻠﻲ واﻟﺒﺪﻧﻲ وﻣﺌﺎت ﻣﻦ ﺳـﺎﻋﺎت ﻋﻤـﺮي ﻣﺤـﺎوﻻ ﺗﻘـﺪﻳﻢ ﺷـﺊ ﻟﻠﻤﻜﺘﺒـﺔ‬
‫اﻟﻌﺮﺑﻴﺔ اﻻﻟﻜﺘﺮوﻧﻴﺔ ﻣﻦ ﺧﻼﻟﻪ. اذا آﺎن اﻟﺘﻔﻜﻴﺮ ﻓﻲ ﻧﺠﺎح هﺬا اﻟﻜﺘﺎب اﻣﺮ ﺑﻌﻴﺪ اﻟﻤـﺪى،‬
‫ﻓﺤﺴﺒﻲ ان ﻻ ﻳﻔﺸﻞ، وان ﻓﺸـﻞ ﻓﻠـﻴﺲ ﻟـﻲ ﺳـﻮى ان أﻋـﻮد اﻟـﻰ آﺮاﺳـﻲ اﻟﻘـﺮاء‬
‫ﺑﺎﺣﺜﺎ ﻋﻦ ﻣﺆﻟﻒ ﻋﺮﺑﻲ ﻓﻲ ﻣﻨﺼﺔ اﻟﻜﺘﺎب ﻳﺮﺷﺪﻧﻲ اﻟﻰ ﺿـﺎﻟﺘﻲ ﻓـﻲ ﻣﻮاﺟﻬـﺔ اﻟﻌﺼـﺮ‬
                                                                 ‫اﻟﺤﺎﻟﻲ ﻟﺘﻘﻨﻴﺔ اﻟﻤﻌﻠﻮﻣﺎت.‬
‫اﺧﻴﺮا، اود ان اﻋﺘﺬر ﺷﺪﻳﺪ اﻻﻋﺘﺬار ﻋﻦ ﻋﺪم ارﻓﺎق ﺑﺮﻳﺪي اﻻﻟﻜﺘﺮوﻧـﻲ ﻋﻠـﻰ ﺻـﻔﺤﺎت‬
‫اﻟﻜﺘﺎب -ﻻﺳﺒﺎب ﺷﺨﺼﻴﺔ- رﻏﻢ اﻧﻨﻲ ﻟﺴﺖ ﻣﻠﺰم ﺑﺎرﻓﺎﻗﻪ ﻃﺎﻟﻤﺎ آﻮﻧـﻪ آﺘـﺎب ﻣﺠـﺎﻧﻲ‬
‫ﻟﻠﺠﻤﻴﻊ، ﻓﻼ ﺗﺘﻮﻗﻊ دﻋﻤﺎ ﻓﻨﻴﺎ ﻣﻨﻲ. آﻤﺎ ارﺟﻮ ان ﻻ ﺗﺤﺎول اﻟﻐﺎء اﺳـﻤﻲ ﻣـﻦ ﺻـﻔﺤﺎت‬
‫اﻟﻜﺘﺎب واﺳـﺘﺒﺪاﻟﻪ ﺑﺎﺳـﻤﻚ او اﺳـﻢ ﺷـﺨﺺ ﻋﺰﻳـﺰ ﻋﻠـﻰ ﻗﻠﺒـﻚ، ﻓـﺎن ذﻟـﻚ ﻻ ﻳﺮﺳـﻢ‬
                                                                  ‫اﻻﺑﺘﺴﺎﻣﺔ ﻋﻠﻰ ﺷﻔﺘﺎي.‬


                                                                         ‫ﺗﺮآﻲ اﻟﻌﺴﻴﺮي‬
                                                                     ‫اﻟﻈﻬﺮان – ﻳﻨﺎﻳﺮ 2002‬
    ‫اﻟﺠﺰء اﻻول‬


‫اﻻﺳﺎﺳﻴﺎت‬
                                              ‫2‬


                                      ‫اﻟﻔﺼﻞ اﻻول‬
                  ‫ﺗﻌﺮف ﻋﻠﻰ ‪Visual Basic‬‬


‫ﺑﺴﻢ اﷲ ﻧﺒﺪأ وﻋﻠﻰ ﺑﺮآﺘﻪ ﻧﺴﻴﺮ ﻣﻊ اﻟﺠﻤﻠﺔ ‪ .Visual Basic‬ﺗﺨﺘﻠﻒ وﺟﻬﺎت اﻟﻨﻈﺮ ﺑﻴﻦ‬
‫اﻟﻤﺒﺮﻣﺠﻴﻦ ﺣـﻮل ﺗﻌﺮﻳـﻒ او ﺗﺼـﻨﻴﻒ ‪ ،Visual Basic‬هـﻞ ‪ Visual Basic‬ﻟﻐـﺔ ﺑﺮﻣﺠـﺔ ام‬
‫ﺑﺮﻧﺎﻣﺞ ﺗﺼﻤﻴﻢ ﻧﻮاﻓـﺬ ام ﻣﻨـﺘﺞ ﻣﺘﻜﺎﻣـﻞ؟ ﺗﻘﻨﻴـﺎ، ‪ Visual Basic‬ﻋﺒـﺎرة ﻋـﻦ ﻣﻜﺘﺒـﺔ ﻣـﻦ‬
‫اﻟﻤﻜﺘﺒﺎت ﺗﻮﻓﺮ ﻋﺪة اواﻣﺮ ﺑﺮﻣﺠﻴﺔ ﻣﺘﻜﺎﻣﻠﺔ ﻣﻊ اﺑﻨﺘﻬـﺎ ‪– Visual Basic for Application‬‬
‫ﺗﺨﺘﺼﺮ ‪ .VBA‬اﻻ ان اﻟﻤﺘﻌﺎرف ﻋﻠﻴﻪ ﺑﻴﻦ اﻟﻤﺒـﺮﻣﺠﻴﻦ هـﻮ ان ‪ Visual Basic‬ﻟﻐـﺔ ﺑﺮﻣﺠـﺔ‬
‫وﺑﺮﻧﺎﻣﺞ ﺗﺼﻤﻴﻢ ﻧﻮاﻓﺬ وﻣﻜﺘﺒﺎت ﺗﺸﻐﻴﻠﻴﺔ، أي ﺑﺎﺧﺘﺼﺎر هﻮ ﻣﻨﺘﺞ ﻣﺘﻜﺎﻣﻞ. ﻟﺬﻟﻚ، ﻋﻨﺪﻣﺎ‬
‫اﺗﺤﺪث ﻋﻦ ‪ Visual Basic‬ﻓﻲ هﺬا اﻟﻜﺘﺎب ﻓﺎﻧﻨﻲ اﻗﺼﺪ ﺟﻤﻴﻊ اﻟﺘﻌﺮﻳﻔﺎت اﻟﺴﺎﺑﻘﺔ، ﻓﻠﻮ‬
‫ذآﺮت ﻣﺰاﻳﺎ ﻟﻐﺔ ‪ Visual Basic‬ﻓـﺎﻧﻨﻲ اﻗﺼـﺪ اﻟﻠﻐـﺔ اﻟﺤﻨﻮﻧـﺔ ‪ ،BASIC‬وﻟـﻮ ﺗﺤـﺪﺛﺖ ﻋـﻦ‬
‫دوال واﺟﺮاءات ‪ Visual Basic‬ﻓﺎﻧﻨﻲ اﻟﻤﺢ اﻟﻰ ﻣﻜﺘﺒﺎت ‪ Visual Basic‬اﻟﺘﺸـﻐﻴﻠﻴﺔ، وﻟـﻮ‬
‫ﺗﻄﺮﻗﺖ اﻟﻰ ﺑﻴﺌﺔ اﻟﺘﻄﻮﻳﺮ اﻟﻤﺘﻜﺎﻣﻠﺔ ﻟـ ‪– Visual Basic‬آﻤﺎ ﻓﻲ اﻟﻔﻘـﺮة اﻟﺘﺎﻟﻴـﺔ- ﻓـﺎﻧﻨﻲ‬
                                                       ‫اﻗﺼﺪ ﺑﺮﻧﺎﻣﺞ ﺗﺼﻤﻴﻢ اﻟﻨﻮاﻓﺬ.‬


                                            ‫ﺑﻴﺌﺔ اﻟﺘﻄﻮﻳﺮ اﻟﻤﺘﻜﺎﻣﻠﺔ ‪IDE‬‬
‫ﺑﺮاﻣﺠﻚ وﻣﺸﺎرﻳﻌﻚ ﺗﺴﺘﻄﻴﻊ اﻧﺠﺎزهﺎ ﺑﺎﺳﺘﺨﺪام اﺑﺴـﻂ ﺑﺮﻧـﺎﻣﺞ ﻳـﺄﺗﻲ ﻣـﻊ ‪Windows‬‬
‫واﻟــﺬي ﻳــﺪﻋﻰ ‪ .Notepad‬اﻻ اﻧﻨــﻲ –وﷲ اﻟﺤﻤــﺪ- ﻟــﻢ اﻗﺎﺑــﻞ ذﻟــﻚ اﻟﺸــﺨﺺ اﻟــﺬي‬
‫ﻳﺴﺘﺨﺪم اﻟـ ‪ Notepad‬آﻲ ﻳﺼﻤﻢ ﺑﺮﻧﺎﻣﺞ ﻳﻨﻔﺬ ﺗﺤﺖ ‪ .Visual Basic‬ﻻن ‪Visual Basic‬‬
 ‫ـ‬            ‫ـ‬       ‫ـ‬     ‫ـ‬        ‫ـ‬
‫ﻳـﻮﻓﺮ ﻟـﻚ ادوات ﻓـﻲ ﻗﻤـﺔ اﻟﺮوﻋـﺔ ﻣﺠﺘﻤﻌـﺔ ﺗﺤـﺖ ﻣﺴـﻤﻰ ﺑﻴﺌـﺔ اﻟﺘﻄـﻮﻳﺮ اﻟﻤﺘﻜﺎﻣﻠـﺔ‬
                                          ‫ـ‬       ‫ـ‬        ‫ـ‬    ‫ـ‬          ‫ـ‬    ‫ـ‬
‫‪– Integrated Development Environment‬ﺗﺨﺘﺼـﺮ ‪ -IDE‬ﺗـﻮﻓﺮ ﻟـﻚ آـﻞ ﻣـﺎ ﺗﺤﺘﺎﺟـﻪ‬
‫ﻟﺘﺼﻤﻴﻢ ﻧﻮاﻓﺬ وآﺘﺎﺑﺔ اآﻮاد ﺑﺮاﻣﺠﻚ. ﺑﻞ ﺗﻘﺪم ﻟـﻚ ﺧـﺪﻣﺎت –ﺧﻤـﺲ ﻧﺠـﻮم- اآﺜـﺮ ﻣـﻦ‬
‫ذﻟﻚ، آﺨﺪﻣـﺔ اﻟﺘﻨﻘـﻴﺢ ‪ ،Debugging‬ادارة ﻣﻠﻔـﺎت ﻣﺸـﺮوﻋﻚ، ﺗﺤﺮﻳـﺮ اﻟﻘـﻮاﺋﻢ، ﺗﻌـﺪﻳﻞ‬
                                           ‫وإﻧﺸﺎء ﻗﻮاﻋﺪ اﻟﺒﻴﺎﻧﺎت ... اﻟﺦ ﺷﻜﻞ 1-1.‬
                                              ‫3‬




                               ‫ﺷﻜﻞ 1-1: ﺑﻴﺌﺔ اﻟﺘﻄﻮﻳﺮ اﻟﻤﺘﻜﺎﻣﻠﺔ ﻟـ ‪.Visual Basic‬‬

‫اذا آﻨﺖ ﺟﺪﻳﺪا ﻋﻠﻰ هﺬﻩ اﻟﺒﻴﺌﺔ –أي ﻟﻢ ﺗﺴﺘﺨﺪم 5‪ -VB‬ﻓﻤﻦ اﻟﻀﺮوري اﻟـﺘﻤﻌﻦ ﻓـﻲ‬
‫آﻠﻤﺎت هﺬا اﻟﻔﺼـﻞ ﺑﺎﻟـﺬات واﻻ ﻓﺎﻧـﻚ ﻟـﻦ ﺗـﺪل اﻟﻄـﺮق اﻟﻤﺆدﻳـﺔ اﻟـﻰ ﺳـﺎﺣﺔ اﻟﻌﻤـﻞ.‬
‫اﻟﻄﺮق ﺳﺘﻜﻮن ﻧﻮاﻓﺬ ﺑﻴﺌﺔ اﻟﺘﻄﻮﻳﺮ، واﻟﻌﻤﻞ هﻮ اﻟﺴﺒﺐ اﻟﺬي ﺟﻌﻠﻚ –ﻋﻠﻰ ﻣﺎ اﻋﺘﻘـﺪ-‬
                                                                  ‫ﺗﻘﺮأ هﺬا اﻟﻜﺘﺎب.‬
‫آﻤﺎ ﺗﻼﺣﻆ ﻓﻲ ﺷﻜﻞ 1-1، ﺗﺤﺘﻮي ﺑﻴﺌﺔ اﻟﺘﻄﻮﻳﺮ ﻋﻠﻰ اﻟﻜﺜﻴﺮ ﻣـﻦ اﻟﻨﻮاﻓـﺬ اﻟﻤﺤﻀـﻮﻧﺔ‬
‫ﺑﻬــﺎ ‪ Child Windows‬واﻟﻌﺪﻳــﺪ ﻣــﻦ اﻟﻘــﻮاﺋﻢ ‪ Menus‬وﻣﺠﻤﻮﻋــﺎت ﻣــﻦ اﻻزرار ﺗــﺪﻋﻰ‬
                              ‫اﺷﺮﻃﺔ اﻻدوات ‪ ،Toolbars‬واﻟﻴﻚ ﻳﺎ ﺳﻴﺪي ﺗﻔﺎﺻﻴﻠﻬﺎ:‬

                                          ‫ﻧﻮاﻓﺬ ﺑﻴﺌﺔ اﻟﺘﻄﻮﻳﺮ اﻟﻤﺘﻜﺎﻣﻠﺔ‬
‫اذا آﻨﺖ ﻣﻦ ﺟﻴﻞ ﻣﺒﺮﻣﺠﻲ ‪ Visual Basic‬اﻻﺻﺪار اﻟﺨﺎﻣﺲ ﻓﺎﻧﺘﻘﻞ اﻟـﻰ ﻓﻘـﺮة "ﻧﺎﻓـﺬة‬
‫ﻋﺮض اﻟﺒﻴﺎﻧﺎت ‪ "Data View‬ﻻﻧﻪ ﻻ ﻳﻮﺟﺪ أي ﺷﺊ ﺟﺪﻳﺪ اوﺿﺤﻪ ﻟﻚ هﻨﺎ. اﻣﺎ ان آﻨـﺖ‬
‫ﻣﻦ اﻻﺟﻴﺎل اﻻﻗـﺪم، ﻓـﺎول ﺷـﺊ ﻗـﺪ ﻳﺸـﺪ اﻧﺘﺒﺎهـﻚ هـﻮ أن اﻟﻨﺎﻓـﺬة اﻟﺮﺋﻴﺴـﻴﺔ ﻟﺒﻴﺌـﺔ‬
‫اﻟﺘﻄـﻮﻳﺮ اﺻـﺒﺤﺖ ﻣـﻦ اﻟﻨـﻮع ﻣﺘﻌـﺪد اﻟﻤﺴـﺘﻨﺪات ‪– Multiple Document Interface‬‬
‫ﺗﺨﺘﺼﺮ ‪ ،MDI‬وﺳﺘﻼﺣﻆ اﺷـﺘﻤﺎﻟﻬﺎ ﻋﻠـﻰ ﻧﻮاﻓـﺬ ﺟﺪﻳـﺪة، ﺑﺎﻻﺿـﺎﻓﺔ إﻟـﻰ ﺗﻄـﻮﻳﺮ ﺑﻌـﺾ‬
‫اﻟﻨﻮاﻓﺬ اﻟﺴﺎﺑﻘﺔ آﻨﺎﻓﺬة ﻣﺴﺘﻜﺸﻒ اﻟﻤﺸـﺮوع او اﻟﺨﺼـﺎﺋﺺ. واول ﻧﺎﻓـﺬة ﺳـﻨﺒﺪأ ﺑﻬـﺎ‬
                                                        ‫هﻲ ﻣﻦ اﻟﻨﻮاﻓﺬ اﻟﺠﺪﻳﺪة:‬
                                                    ‫4‬


                                                   ‫ﻧﺎﻓﺬة ﻣﺸﺮوع ﺟﺪﻳﺪ ‪New Project‬‬
‫ﻋﻨﺪﻣﺎ ﺗﻘﻮم ﺑﺘﺸﻐﻴﻞ ﻣﻨﺼﺔ اﻟﻌﻤﻞ ‪ Visual Basic‬ﻻول ﻣﺮة، ﻓﺎن ﻟﻬﺬﻩ اﻟﻨﺎﻓﺬة اﺣﺘﻤـﺎل‬
 ‫ـ‬       ‫ـ‬       ‫ـ‬     ‫ـ‬      ‫ـ‬
‫ﻣﺆآ ـﺪ ﻟﻠﻈﻬ ـﻮر. ﻓﻌ ـﻦ ﻃﺮﻳﻘﻬ ـﺎ ﺗﺴ ـﺘﻄﻴﻊ اﻻﺧﺘﻴ ـﺎر ﺑ ـﻴﻦ أﻧ ـﻮاع ﻋ ـﺪة ﻣ ـﻦ اﻟﻤﺸ ـﺎرﻳﻊ آ ــ‬
                                     ‫ـ ـ‬               ‫ـ‬     ‫ـ‬        ‫ـ‬       ‫ـ‬       ‫ـ‬
‫‪ .... ActiveX DLL ،ActiveX EXE ،Standard EXE‬اﻟﺦ. ﺣﺪد اﻟﻨﻮع ‪ Standard EXE‬ﺛﻢ‬
‫اﻧﻘﺮ ﻋﻠﻰ اﻟﺰر ‪ Open‬او اﺿـﻐﻂ ﻋﻠـﻰ اﻟﻤﻔﺘـﺎح ]‪ .[ENTER‬ﻓﺎﻟﻘﺎﻋـﺪة اﻟﺴـﺎﺋﺪة ﻟﺠﻤﻴـﻊ‬
‫آﺘﺐ ‪ Visual Basic‬اﻟﺘﻌﺮﻳﻔﻴﺔ ﺗﺒﺪأ اﻟﺸﺮح داﺋﻤﺎ ﺑﺎﻟﻨﻮع ‪ Standard EXE‬وﻟـﻦ اﺷـﺬ ﻋـﻦ‬
     ‫هﺬﻩ اﻟﻘﺎﻋﺪة، ﻓﺎﻧﺖ ﻻ ﺗﺮﻳﺪ ﻣﻌﺮﻓﺔ ﻃﺮﻳﻘﺔ ﻃﺒﺦ اﻟﻜﺒﺴﺔ ﻗﺒﻞ ان ﺗﺘﻌﻠﻢ ﻗﻠﻲ اﻟﺒﻴﺾ!‬
‫اذا آﺎﻧﺖ هﺬﻩ اﻟﻨﺎﻓﺬة ﺗﺴﺒﺐ ﻟﻚ ازﻋﺎج -وﻟﻮ ﺑﺴﻴﻂ- ﻓﻲ آﻞ ﻣﺮة ﺗﺸﻐﻞ ﻓﻴﻬـﺎ ‪Visual‬‬
‫‪ ،Basic‬ﺗﺴـﺘﻄﻴﻊ اﻟﻐـﺎء ﻓﻜـﺮة ﻇﻬﻮرهـﺎ ﻋـﻦ ﻃﺮﻳـﻖ ﺗﺤﺪﻳـﺪ اﻟﺨﻴـﺎر ‪Don’t show this‬‬
‫‪ dialog in the future‬اﻟﻤﻮﺟﻮد ﻓﻲ اﺳﻔﻠﻬﺎ ﺣﺘﻰ ﻻ ﺗﻌﻜﺮ ﻣﺰاﺟـﻚ، وﺗﻜـﻮن رﻓﻴﻘـﺎ ﻟـﻲ‬
                                                                      ‫ﺣﺘﻰ ﻧﻬﺎﻳﺔ اﻟﻜﺘﺎب.‬

 ‫إذا ﻟﻢ ﻳﺮق ﻟﻚ هﺬا اﻟﺘﻐﻴﻴﺮ، واردت اﻟﻌﻮدة إﻟﻰ اﻟﻮﺿﻊ اﻟﺴﺎﺑﻖ، ﻓﺎﺧﺘﺮ‬              ‫ﻣﻼﺣﻈﺔ:‬
 ‫اﻷﻣﺮ …‪ Options‬ﻣﻦ ﻗﺎﺋﻤﺔ ‪ ،Tools‬وﻣﻦ ﻣﺮﺑﻊ اﻟﺤﻮار اﻟﺬي ﻳﻈﻬﺮ‬
 ‫اﻣﺎﻣﻚ اﺧﺘﺮ ﺗﺒﻮﻳﺐ ُ‪ ،Environment‬واﻧﻘﺮ ﻋﻠﻰ اﻟﺨﻴﺎر ‪Prompt for‬‬
                                                       ‫‪.project‬‬

                                           ‫ﻧﺎﻓﺬة ﻣﺼﻤﻢ اﻟﻨﻤﺎذج ‪Form Designer‬‬
‫هﺬﻩ اﻟﻨﺎﻓـﺬة ﺗﻌﺘﺒـﺮ ﺳـﺮ ﻧﺠـﺎح ‪ ،Visual Basic‬وهـﻲ اﺷـﻬﺮ ﻧﻮاﻓـﺬ ‪ Visual Basic‬ﻣﻨـﺬ‬
‫اﻻﺻﺪار اﻻول ﻣﻊ اﻟﻌﻨﻮان اﻻﺑﺘﺪاﺋﻲ ﻟﻬﺎ 1‪ .Form‬ﻋﻦ ﻃﺮﻳﻖ هﺬﻩ اﻟﻨﺎﻓﺬة ﺗﻘـﻮم ﺑﻌﻤﻠﻴـﺔ‬
‫ﺗﺼﻤﻴﻢ واﺟﻬﺔ ﺑﺮﻧﺎﻣﺠﻚ اﻣﺎ ﺑﺘﻌﺪﻳﻞ ﺧﺼﺎﺋﺼـﻬﺎ او وﺿـﻊ ﺑﺎﻗـﺔ ادوات ﻋﻠﻴﻬـﺎ ﺑﺎﺳـﺘﺨﺪام‬
           ‫ـ‬         ‫ـ‬         ‫ـ‬
‫اﻟﻔـ ـﺄرة ‪ Mouse‬ﻣﺒﻴﻨـ ـﺔ ﻟـ ـﻚ ﻗـ ـﻮة وﻧﺠـ ـﺎح ﻓﻜـ ـﺮة ﻟﻐـ ـﺎت اﻟﺒﺮﻣﺠـ ـﺔ اﻟﻤﺮﺋﻴـ ـﺔ ‪Visual‬‬
                                       ‫ـ‬        ‫ـ‬       ‫ـ‬     ‫ـ ـ‬                    ‫ـ‬
‫‪ .Programming Languages‬ﻓﻘﺪ اﻧﺘﻬﻰ ﻋﺼﺮ ﺗﺼﻤﻴﻢ اﻟﺸﺎﺷﺎت ﺑﺎﻻآﻮاد او ﺗﻌﻠﻴﻤـﺎت‬
      ‫اﻟﻤﺎآﺮو ‪ Macro‬آﻤﺎ آﻨﺎ ﻧﻔﻌﻞ ﻓﻲ زﻣﻦ اﻗﺮاص 52.5 واﺷﺮﻃﺔ اﻟﺘﺴﺠﻴﻞ ‪.Tapes‬‬
‫ﻃﺮﻳﻘﺔ وﺿﻊ اﻻدوات ﻋﻠﻰ ﻧﺎﻓﺬة اﻟﻨﻤﻮذج اﺷﺒﻪ ﻣـﺎ ﺗﻜـﻮن ﺑﻌﻤﻠﻴـﺔ رﺳـﻢ ﻣﺮﺑﻌـﺎت آﻤـﺎ‬
‫ﻓﻲ ﺑﺮﻧﺎﻣﺞ اﻟﺮﺳﺎم ‪ .Paint‬اﻟﻤﺰﻳـﺪ اﻳﻀـﺎ، ﻋﻤﻠﻴـﺎت اﻟﺘﺤﺮﻳـﺮ آﺎﻟﻨﺴـﺦ واﻟﻠﺼـﻖ واﻟﻘـﺺ‬
                                             ‫ﻣﺪﻋﻮﻣﺔ ﻋﻠﻰ ﺟﻤﻴﻊ اﻻدوات اﻟﺘﻲ ﺗﻀﻌﻬﺎ.‬

 ‫ﻧﺎﻓﺬة اﻟﻨﻤﻮذج هﻲ اﺳﻢ ﻣﺨﺘﺼﺮ ﻣﻦ ﻧﺎﻓﺬة ﻣﺼﻤﻢ اﻟﻨﻤـﺎذج واﻟﻤﻘﺼـﺪ‬                   ‫ﻣﻼﺣﻈﺔ:‬
 ‫واﺣﺪ. ﻟﺬﻟﻚ، ﺳﺘﻼﺣﻆ اﻧﻨﻲ اﺳﺘﺨﺪم اﻟﻤﺼـﻄﻠﺢ ﻧﺎﻓـﺬة اﻟﻨﻤـﻮذج ﻓـﻲ‬
                                            ‫آﺂﻓﺔ ارﺟﺎء اﻟﻜﺘﺎب .‬
                                                 ‫5‬


                                             ‫ﻧﺎﻓﺬة ﺻﻨﺪوق اﻻدوات ‪Toolbox‬‬
‫ﺑﻌﺪ ان ﺗﻈﻬﺮ ﻟﻨﺎ ﻧﺎﻓﺬة اﻟﻨﻤﻮذج اﻟﺴﺎﺑﻘﺔ، ﻓﺎن ﺷـﻬﻮة وﺿـﻊ اﻻدوات ﻋﻠﻴﻬـﺎ ﺗﺼـﻞ اﻟـﻰ‬
   ‫ـ‬            ‫ـ‬                        ‫ـ‬    ‫ـ‬     ‫ـ‬     ‫ـ‬             ‫ـ‬
‫ﻗﻤﺘﻬ ـﺎ. واﻻدوات ﻣﻮﺟ ـﻮدة ﻓ ـﻲ ﻧﺎﻓ ـﺬة ﺻ ـﻨﺪوق اﻻدوات ‪ Toolbox‬ﺷ ـﻜﻞ 1-2 اﻟﺘ ـﻲ‬
‫ﺗﻌﺮض ﻟﻚ 02 أداة ﻗﻴﺎﺳﻴﺔ ﻣﺪﻣﺠﺔ ﻓﻲ ﺟﻤﻴﻊ ﺑﺮاﻣﺠﻚ اﻟﻤﺼﻤﻤﺔ ﺗﺤﺖ ‪،Visual Basic‬‬
‫وﻗﺪ ﺗﺤﺘﻮي ﻋﻠـﻰ ﻣﺠﻤﻮﻋـﺔ ادوات اﺿـﺎﻓﻴﺔ ﺗـﺪﻋﻰ ‪- ActiveX Controls‬ﻣـﺎزال اﻟﻮﻗـﺖ‬
‫ﻣﺒﻜﺮا ﺟﺪا ﻟﻠﺤﺪﻳﺚ ﻋﻨﻬﺎ. ﻣﻊ ان اﻻدوات ﻋﺪدهﺎ 02 أداة اﻻ اﻧﻪ ﻳﻮﺟـﺪ 12 زر ‪،Buttons‬‬
‫هﺬا اﻟﺰر اﻻﺿﺎﻓﻲ ﻣﻮﺟﻮد ﻓﻲ اﻟﺮآﻦ اﻟﻌﻠﻮي اﻻﻳﺴﺮ ﻣـﻦ اﻻدوات ﻋﻠـﻰ ﺷـﻜﻞ ﻣﺆﺷـﺮ‬
‫‪ Pointer‬وﻇﻴﻔﺘﻪ اﻻﺳﺎﺳﻴﺔ اﻟﻐﺎء ﻋﻤﻠﻴﺔ ﻃﻠﺐ رﺳﻢ أداة. ﻻ ﺗﺸﻐﻞ ﻧﻔﺴﻚ ﺑـﻪ آﺜﻴـﺮا،‬
‫ﻓﻬﻮ ﻳﻀﻐﻂ ﻧﻔﺴﻪ ﺗﻠﻘﺎﺋﻴﺎ ﺑﻤﺠﺮد اﻧﺘﻬﺎﺋﻚ ﻣﻦ ﻋﻤﻠﻴﺔ رﺳـﻢ او وﺿـﻊ اﻷداة ﻋﻠـﻰ ﻧﺎﻓـﺬة‬
                                                                      ‫اﻟﻨﻤﻮذج.‬




                                              ‫ﺷﻜﻞ 1-2: ﺻﻨﺪوق اﻻدوات ‪.Toolbox‬‬

    ‫ـ‬      ‫ـ‬         ‫ـ‬     ‫ـ‬
‫اذا آ ـﺎن ﻋ ـﺪد اﻻدوات اﻟﻤﻮﺟ ـﻮدة ﻓ ـﻲ ﺻ ـﻨﺪوق اﻻدوات آﺒﻴ ـﺮا ﺟ ـﺪا، ﻓﻴﻔﻀ ـﻞ ان ﺗﻘ ـﻮم‬
                                            ‫ـ‬    ‫ـ‬      ‫ـ‬                ‫ـ‬     ‫ـ‬
‫ﺑﻌﻤﻠﻴﺔ ﺗﻘﺴﻴﻢ اﻻدوات اﻟﻰ ﻣﺠﻤﻮﻋـﺎت ﺗﺨﺘﻔـﻲ وﺗﻈﻬـﺮ ﻣﺘـﻰ ﻣـﺎ ﺷـﺌﺖ ﻋـﻦ ﻃﺮﻳـﻖ‬
‫اﻟﻨﻘﺮ ﺑﺰر اﻟﻔـﺄرة اﻻﻳﻤـﻦ ﻋﻠـﻰ ﻧﺎﻓـﺬة ﺻـﻨﺪوق اﻻدوات واﺧﺘﻴـﺎر اﻻﻣـﺮ …‪ Add Tab‬ﻣـﻦ‬
  ‫ـ‬     ‫ـ‬        ‫ـ‬
‫اﻟﻘﺎﺋﻤـﺔ اﻟﻤﻨﺴـﺪﻟﺔ وﻣـﻦ ﺛـﻢ آﺘﺎﺑـﺔ اﺳـﻢ اﻟﻤﺠﻤﻮﻋـﺔ. ﻃﺮﻳﻘـﺔ ﺗﻨﻈـﻴﻢ ﻣﺤﺘﻮﻳـﺎت آـﻞ‬
                                  ‫ـ‬          ‫ـ‬    ‫ـ‬          ‫ـ‬      ‫ـ‬
‫ﻣﺠﻤﻮﻋﺔ ﺗﺘﺒﻊ اﺳـﻠﻮب اﻟﺴـﺤﺐ واﻻﻟﻘـﺎء ‪ Drag & Drop‬وهـﻮ ﻧﻔـﺲ اﻻﺳـﻠﻮب اﻟـﺬي‬
‫ﺗﺘﺒﻌﻪ ﻟﻨﺴﺦ او ﻧﻘﻞ ﻣﻠﻔﺎت ﺟﻬﺎزك. اﺧﻴﺮا، اذا اردت ﺣﺬف اﻟﻤﺠﻤﻮﻋﺔ، ﻗﻢ ﺑﺎﻟﻨﻘﺮ ﻋﻠـﻰ‬
‫اﺳﻢ اﻟﻤﺠﻤﻮﻋﺔ ﺑﺰر اﻟﻔﺄرة اﻻﻳﻤﻦ واﺧﺘﻴﺎر اﻻﻣﺮ ‪ Delete Tab‬ﻣﻦ اﻟﻘﺎﺋﻤـﺔ اﻟﻤﻨﺴـﺪﻟﺔ،‬
      ‫ﻣﻊ اﻟﻌﻠﻢ ان اﻟﻤﺠﻤﻮﻋﺔ اﻟﺮﺋﻴﺴﺔ واﻟﺘﻲ ﺗﺴﻤﻰ ‪ General‬ﻟﻦ ﺗﺘﻤﻜﻦ ﻣﻦ ﺣﺬﻓﻬﺎ.‬
‫ﻳﺒﺪو اﻧﻨﻲ ﻧﺴﻴﺖ ﻧﻘﻄﺔ ﻣﻬﻤﺔ وهﻲ آﻴـﻒ ﺗﻌـﺮض ﻧﺎﻓـﺬة ﺻـﻨﺪوق اﻻدوات ﻓـﻲ ﺣﺎﻟـﺔ‬
                ‫اﻏﻼﻗﻬﺎ، ﻳﺘﻢ ذﻟﻚ ﻋﻦ ﻃﺮﻳﻖ اﺧﺘﻴﺎر اﻻﻣﺮ ‪ Toolbox‬ﻣﻦ اﻟﻘﺎﺋﻤﺔ ‪.View‬‬

                                  ‫ﻧﺎﻓﺬة اﻟﺨﺼﺎﺋﺺ ‪Properties Windows‬‬
‫ﺑﻤﺠﺮد اﻧﺘﻬﺎﺋﻚ ﻣﻦ وﺿﻊ اﻷداة ﻋﻠﻰ ﻧﺎﻓﺬة اﻟﻨﻤﻮذج، ﻓﺎن ﻋﻴﻨﻴـﻚ ﺳـﺘﺒﺤﺚ ﻋـﻦ ﻣﻮﻗـﻊ‬
‫ﻧﺎﻓﺬة اﻟﺨﺼﺎﺋﺺ واﻟﺘﻲ ﻣﻦ ﺧﻼﻟﻬﺎ ﺳﺘﺘﻤﻜﻦ ﻣﻦ ﺗﻌﺪﻳﻞ ﺧﺼﺎﺋﺺ اﻷداة او ﺣﺘﻰ ﻧﺎﻓـﺬة‬
                                                ‫6‬


‫اﻟﻨﻤﻮذج ‪ ،Form‬ﻣﻦ هﺬﻩ اﻟﺨﺼﺎﺋﺺ اﻟﺤﺠﻢ، اﻟﻤﻮﻗﻊ، اﻟﻠﻮن، اﻟﻌﻨﻮان .... اﻟﺦ. اذا آﺎﻧـﺖ‬
‫هﺬﻩ اﻟﻨﺎﻓﺬة ﻣﺨﻔﻴﺔ اﺧﺘﺮ اﻻﻣﺮ ‪ Properties Window‬ﻣﻦ ﻗﺎﺋﻤﺔ ‪ View‬او اﺿـﻐﻂ ﻋﻠـﻰ‬
                                                                    ‫اﻟﻤﻔﺘﺎح ]4‪.[F‬‬
‫ﻓﻲ اﻋﻠﻰ اﻟﻨﺎﻓﺬة ﻳﻮﺟﺪ ﻗﺎﺋﻤﺔ ﺗﺴﻤﻰ ﻓﻲ ﻋﺎﻟﻢ ‪ Visual Basic‬ﺑـﺄداة اﻟــ ‪ComboBox‬‬
‫ﺗﻤﻜﻨﻚ ﻣﻦ ﺗﺤﺪﻳﺪ اﻟﻜﺎﺋﻦ او اﻷداة اﻟﺘﻲ ﺗـﻮد ﻋـﺮض ﺧﺼﺎﺋﺼـﻬﺎ. ﺑﺎﻣﻜﺎﻧـﻚ ﺗﺤﺪﻳـﺪ اﻷداة‬
   ‫ـ‬      ‫ـ‬                 ‫ـ‬         ‫ـ‬
‫ﻣﺒﺎﺷـﺮة ﺑـﺎﻟﻨﻘﺮ ﻋﻠﻴﻬـﺎ -وهـﻲ ﻋﻠـﻰ ﻧﺎﻓـﺬة اﻟﻨﻤـﻮذج- وﺳـﺘﻼﺣﻆ ان ﻣﺤﺘﻮﻳـﺎت ﻧﺎﻓـﺬة‬
                                             ‫ـ‬    ‫ـ‬    ‫ـ‬    ‫ـ‬          ‫ـ ـ‬
‫اﻟﺨﺼﺎﺋﺺ ﻗﺪ ﺗﻐﻴﺮت. اﻟﻤﺰﻳﺪ اﻳﻀﺎ، ﻳﻤﻜﻨﻚ اﺧﺘﻴﺎر ﻃﺮﻳﻘﺔ ﺗﺮﺗﻴـﺐ ﺟـﺪول اﻟﺨﺼـﺎﺋﺺ اﻣـﺎ‬
‫ﺗﺮﺗﻴﺐ اﺑﺠﺪي ‪ Alphabetic‬او ﻣﺼﻨﻒ ‪ .Categorized‬وﺑﺎﻟﻨﺴـﺒﺔ ﻟﻠﺠـﺪول، ﻓـﺎن اﻟﻌﻤـﻮد‬
‫اﻻﻳﺴﺮ ﻳﻌﺮض ﻟﻚ اﻟﺨﺼﺎﺋﺺ اﻟﻤﺘﻮﻓﺮة ﻟﻸداة اﻣﺎ اﻻﻳﻤﻦ ﻓﻴﻌﺮض ﻗﻴﻤﺔ آﻞ ﺧﺎﺻـﻴﺔ ﻣـﻦ‬
‫هﺬﻩ اﻟﺨﺼﺎﺋﺺ. ﺑﻌﺾ اﻟﺨﺼـﺎﺋﺺ ﺗﺴـﺘﻄﻴﻊ ﺗﻌـﺪﻳﻠﻬﺎ ﻣﺒﺎﺷـﺮة ﺑﻜﺘﺎﺑـﺔ ﻗﻴﻤـﺔ ﻋﺪدﻳـﺔ او‬
‫ﺣﺮﻓﻴﺔ آـ ‪ ،Caption‬وﺑﻌﻀﻬﺎ ﻋﻠﻴﻚ اﺧﺘﻴﺎر ﻗﻴﻤﺔ ﻣﻦ ﻋـﺪة ﻗـﻴﻢ آــ ‪ Visible‬او ﻟـﻮن ﻣـﻦ‬
‫ﻣﺠﻤﻮﻋﺔ ﻟﻮح اﻻﻟﻮان آـ ‪ ،BackColor‬وهﻨـﺎك ﻧـﻮع ﻳﻈﻬـﺮ ﻟـﻚ ﻣﺮﺑـﻊ ﺻـﻐﻴﺮ ﻓـﻲ اﻗﺼـﻰ‬
‫ﻳﻤﻴﻦ اﻟﻌﻤﻮد ﻣﻜﺘﻮب ﻋﻠﻴﻪ ﺛـﻼث ﻧﻘـﺎط "..." ﻳﻘﺼـﺪ ﺑـﻪ ﺻـﻨﺪوق ﺣـﻮار ‪ Dialog Box‬ﻟـﻪ‬
                                                    ‫ﺧﻴﺎرات اﺿﺎﻓﻴﺔ آﺎﻟﺨﺎﺻﻴﺔ ‪.Font‬‬

                                 ‫ﻧﺎﻓﺬة ﻣﺴﺘﻜﺸﻒ اﻟﻤﺸﺮوع ‪Project Explorer‬‬
‫ﺗﺰداد اهﻤﻴﺔ هﺬﻩ اﻟﻨﺎﻓﺬة ﺑﺎزدﻳـﺎد ﻋـﺪد اﻟﻤﻠﻔـﺎت اﻟﺘﺎﺑﻌـﺔ ﻟﻤﺸـﺮوﻋﻚ، ﻓﻬـﻲ اﻟﻮﺳـﻴﻠﺔ‬
‫اﻟﻮﺣﻴﺪة اﻟﺘﻲ ﺗﻤﻜﻨﻚ ﻣﻦ ﻋﺮض ﻣﺤﺘﻮﻳﺎت ﻣﺸﺮوﻋﻚ ﻣﺮﺗﺒﺔ ﻋﻠﻰ ﺷﻜﻞ ﺷﺠﺮي ﺑﺮﻣـﻮز‬
‫ﻣﺨﺘﻠﻔﺔ ﺗﺠﺪ ﺷﺮﺣﺎ ﻣﻔﺼﻼ ﻟﻬﺎ ﻓﻲ ﻣﻠﻒ اﻟﺘﻌﻠﻴﻤﺎت. ﺗﺴـﺘﻄﻴﻊ اﻟﻮﺻـﻮل اﻟـﻰ اﻟﺼـﻔﺤﺔ‬
‫اﻟﺘﻲ اﻗﺼﺪهﺎ ﻋﻦ ﻃﺮﻳﻖ ﺗﺤﺪﻳﺪ اﻟﻨﺎﻓﺬة وﻣـﻦ ﺛـﻢ اﻟﻀـﻐﻂ ﻋﻠـﻰ اﻟﻤﻔﺘـﺎح ]1‪ .[F‬ان ﻟـﻢ‬
 ‫ـ‬       ‫ـ‬         ‫ـ‬         ‫ـ‬
‫ﺗﻜ ـﻦ ﻧﺎﻓ ـﺬة ﻣﺴﺘﻜﺸ ـﻒ اﻟﻤﺸ ـﺮوع ﻇ ـﺎهﺮة اﻣﺎﻣ ـﻚ، ﺗﺴ ـﺘﻄﻴﻊ ﻋﺮﺿ ـﻬﺎ ﺑﺎﺧﺘﻴ ـﺎر اﻻﻣ ـﺮ‬
                                    ‫ـ‬          ‫ـ‬      ‫ـ‬       ‫ـ‬         ‫ـ‬      ‫ـ‬
                ‫‪ Project Explorer‬ﻣﻦ ﻗﺎﺋﻤﺔ ‪ View‬او اﻟﻀﻐﻂ ﻋﻠﻰ اﻟﻤﻔﺎﺗﻴﺢ ]‪.[Ctrl +R‬‬

                                             ‫ﻧﺎﻓﺬة ﻣﺤﺮر اﻻآﻮاد ‪Code Window‬‬
‫ﺑﻤﺎ ان ‪ Visual Basic‬ﻟﻐﺔ ﺑﺮﻣﺠﺔ، ﻓﺒﻜﻞ ﺗﺄآﻴﺪ ﻋﻠﻴﻚ آﺘﺎﺑﺔ اآﻮاد وﺗﻌﻠﻴﻤـﺎت اﻟﻠﻐـﺔ. ﻋـﻦ‬
‫ﻃﺮﻳﻖ ﻧﺎﻓﺬة ﻣﺤﺮر اﻻآﻮاد ﻳﻤﻜﻨﻚ ﻋﻤﻞ ذﻟﻚ، ﻓﻬﻲ ﺗﻮﻓﺮ ﻟﻚ ﻣﺤﺮر ﺑﺮﻣﺠـﻲ ذآـﻲ ﺟـﺪا‬
‫وﻣﻨﺴﻖ آﻠﻤﺎت ﻳﻔﺘﺢ ﻧﻔﺲ اﻟﻤﺒﺮﻣﺞ ﻟﻜﺘﺎﺑﺔ اﻻآﻮاد. ﻣـﻦ اﻟﻤﻨﺎﺳـﺐ ان اﻧـﻮﻩ هﻨـﺎ ﺑـﺎن‬
‫ﺑﻌﺾ اﻟﻤﺒﺮﻣﺠﻴﻦ اﻟﻌﺮب اﻟـﺬﻳﻦ ﻳﺴـﺘﺨﺪﻣﻮن ﻧﻈـﻢ ﺗـﺪﻋﻢ ﻣﺠﻤﻮﻋـﺔ ﻣﺤـﺎرف اﻟﺸـﻴﻔﺮة‬
          ‫ـ‬      ‫ـ‬    ‫ـ‬         ‫ـ‬                             ‫ـ‬               ‫ـ‬
‫اﻟﻤﻮﺣ ـﺪة ‪ Unicode‬آ ــ ‪ Windows 2000, XP‬ﻳﻮاﺟﻬ ـﻮن اﺣﻴﺎﻧ ـﺎ ﻣﺸ ـﺎآﻞ ﻓ ـﻲ آﺘﺎﺑــﺔ‬
‫اﻟﺤﺮوف اﻟﻌﺮﺑﻴﺔ، واﻟﺴﺒﺐ ﺧﺎرج ﻧﻈﺎق اﻟﻔﻘﺮة ﻟﻜـﻦ ﺣﻠﻬـﺎ ﻳـﺘﻢ ﻋـﻦ ﻃﺮﻳـﻖ ﺗﻐﻴﻴـﺮ ﻧـﻮع‬
‫اﻟﺨﻂ ‪ Font‬اﻟﻲ ﺧﻂ ﻳـﺪﻋﻢ اﻟﻠﻐـﺔ اﻟﻌﺮﺑﻴـﺔ آــ )‪ .Courier New (Arabic‬ﻳﻤﻜﻨـﻚ ﻋﻤـﻞ‬
‫ذﻟــﻚ ﺑﺎﻟﺘﻮﺟــﻪ اﻟــﻰ ﺧﺎﻧــﺔ اﻟﺘﺒﻮﻳــﺐ ‪ Editor Format‬اﻟﻤﻮﺟــﻮدة ﻓــﻲ ﺻــﻨﺪوق اﻟﺤــﻮار‬
          ‫‪ Options‬واﻟﺬي ﺗﺼﻞ اﻟﻴﻪ ﻋﻦ ﻃﺮﻳﻖ اﺧﺘﻴﺎر اﻻﻣﺮ ‪ Options‬ﻣﻦ ﻗﺎﺋﻤﺔ ‪.Tools‬‬
                                              ‫7‬


‫ﺑﺎﻣﻜﺎﻧﻚ ﻣﺸﺎهﺪة ﻧﺎﻓﺬة ﻣﺤﺮر اﻻآﻮاد اﻣﺎ ﺑﺎﻟﻨﻘﺮ اﻟﻤﺰدوج ﺑﺎﻟﻔـﺄرة ﻋﻠـﻰ اﻷداة او ﻧﺎﻓـﺬة‬
    ‫ـ‬        ‫ـ‬      ‫ـ‬        ‫ـ‬
‫اﻟﻨﻤـﻮذج، او ﺑﺎﻟﻀـﻐﻂ ﻋﻠـﻰ اﻟﻤﻔﺘـﺎح ]7‪ .[F‬اﺧﻴـﺮا، اذا آﻨـﺖ ﻻ ﺗﺤـﺐ ﻣﺸـﺎهﺪة اﻓـﻼم‬
                                      ‫ـ‬             ‫ـ‬       ‫ـ‬      ‫ـ‬         ‫ـ‬
‫اﻟﺮﻋﺐ اﻟﺒﺮﻣﺠﻲ اﻟﻤﺘﻤﺜﻠﺔ ﻓﻲ اﻻآﻮاد اﻟﻄﻮﻳﻠﺔ، ﺗﻤﻜﻨﻚ هﺬﻩ اﻟﻨﺎﻓﺬة ﻣـﻦ ﻋـﺮض اﺟـﺮاء‬
‫ﻣﻌﻴﻦ واﺧﻔﺎء ﺳﺎﺋﺮ اﻻآﻮاد ﻋﻦ ﻃﺮﻳﻖ اﻟﻨﻘﺮ ﻋﻠﻰ اﻟﺰر ‪ Procedure View‬اﻟﻤﻮﺟﻮد ﻓـﻲ‬
‫اﻟﺮآﻦ اﻟﺴﻔﻠﻲ اﻻﻳﺴﺮ ﻣﻦ اﻟﻨﺎﻓﺬة، ﻟﻜﻦ ﻋﻤﻠﻴﺔ اﻟﺘﻨﻘﻞ ﺑﻴﻦ اﻻﺟﺮاءات ﺳـﺘﻜﻮن ﻣﻤﻠـﺔ‬
‫ﺑﻌﺾ اﻟﺸﺊ ﻋـﻦ ﻃﺮﻳـﻖ اﻟﻘـﺎﺋﻤﺘﻴﻦ ‪ ComboBoxes‬اﻟﻤﻮﺟﻮدﺗـﺎن ﻓـﻲ اﻋﻠـﻰ اﻟﻨﺎﻓـﺬة،‬
‫اﻟﻘﺎﺋﻤﺔ اﻟﻴﺴﺮى ﺗﻌﺮض ﺟﻤﻴﻊ اﻻدوات اﻟﻤﻮﺟﻮدة ﻓﻲ ﻧﺎﻓﺬة اﻟﻨﻤﻮذج اﻟﺤﺎﻟﻴﺔ، ﺑﺎﻻﺿﺎﻓﺔ‬
‫إﻟﻰ اﻟﻨﻤﻮذج ﻧﻔﺴﺔ، وآﺬﻟﻚ اﻟﻌﺒﺎرة )‪ (General‬وهﻲ ﺗﺸﻴﺮ إﻟﻰ ﻗﺴﻢ اﻻﻋﻼﻧﺎت ﻓـﻲ‬
‫اﻟﻨﻤﻮذج وآﺬﻟﻚ اﻻﺟـﺮاءات واﻟـﺪوال اﻟﺘـﻲ ﺗﻘـﻮم ﺑﺎﻧﺸـﺎءهﺎ، واﻟﻘﺎﺋﻤـﺔ اﻟﻴﻤﻨـﻰ ﺗﻌـﺮض‬
               ‫ﺟﻤﻴﻊ اﻻﺟﺮاءات واﻻﺣﺪاث اﻟﻤﺮﺗﺒﻄﺔ ﺑﻤﺎ ﻳﺘﻢ اﺧﺘﻴﺎرة ﻓﻲ اﻟﻘﺎﺋﻤﺔ اﻻوﻟﻰ.‬

                                        ‫ﻧﺎﻓﺬة ﻣﺨﻄﻂ اﻟﻨﻤﻮذج ‪Form Layout‬‬
‫اﺧﺘﻴﺎر اﻻﻣﺮ ‪ Form Layout Window‬اﻟﻤﻮﺟﻮد ﻓﻲ ﻗﺎﺋﻤﺔ ‪ View‬ﻳﺆدي اﻟﻰ ﻇﻬﻮر هـﺬﻩ‬
‫اﻟﻨﺎﻓﺬة واﻟﺘﻲ ﺗﻌﻄﻴﻚ رؤﻳﺔ ﻣﺒﺴﻄﺔ ﻋﻦ ﻣﻮﻗﻊ وﺣﺠـﻢ ﻧﺎﻓـﺬة اﻟﻨﻤـﻮذج اﻟﺘـﻲ ﺗﺼـﻤﻤﻬﺎ‬
‫وﻗﺖ اﻟﺘﻨﻔﻴﺬ ﻣﻦ اﻟﺸﺎﺷﺔ. اﻻ ان اﻟﻔﺎﺋﺪة اﻟﻜﺒﺮى اﻟﺘﻲ ﺗﺠﻨﻴﻬﺎ ﻣﻦ هﺬﻩ اﻟﻨﺎﻓـﺬة ﺗﻜـﻮن‬
‫ﻣﻘﺎرﻧﺔ ﺣﺠﻢ ﻧﺎﻓﺬة اﻟﻨﻤﻮذج ﻣﻊ اﻟﻜﺜﺎﻓﺎت اﻟﻨﻘﻄﻴـﺔ ‪ Resolutions‬اﻟﻤﺨﺘﻠﻔـﺔ ﻟﻠﺸﺎﺷـﺔ.‬
‫ﻟﻌﺮض هﺬﻩ اﻟﻜﺜﺎﻓﺎت، اﻧﻘﺮ ﺑﺰر اﻟﻔﺄرة اﻻﻳﻤـﻦ ﻋﻠـﻰ اﻟﻨﺎﻓـﺬة واﺧﺘـﺮ اﻻﻣـﺮ ‪Resolution‬‬
                                                   ‫‪ Guide‬ﻣﻦ اﻟﻘﺎﺋﻤﺔ اﻟﻤﻨﺴﺪﻟﺔ.‬

                                 ‫ﻧﺎﻓﺬة ﻣﻮﺟﺔ اﻻواﻣﺮ ‪Immediate Window‬‬
‫ﺗﻤﻜﻨﻚ هﺬﻩ اﻟﻨﺎﻓﺬة ﻣـﻦ آﺘﺎﺑـﺔ اواﻣـﺮ وﺗﻌﻠﻴﻤـﺎت ﻟﻐـﺔ ‪ Visual Basic‬ﺑﺴـﻴﻄﺔ ﻟﻼﺧﺘﺒـﺎر‬
‫واﻟﺘﺠﺮﺑﺔ، ﻗﺪ ﺗﺤﺘﺎﺟﻬﺎ ﻣﺜﻼ ﻻﺧﺘﺒﺎر اﻣﺮ ﻣﻌﻴﻦ او ﻗﻴﻤﺔ ﻣﺘﻐﻴﺮ ﻣﻌﻴﻦ ﻗﺒﻞ وﺿﻊ اﻟﻜﻮد ﻟـﻪ.‬
‫ﺑﻌﺪ ان ﺗﻜﺘﺐ اﻻﻣﺮ، اﻟﻤﻔﺘﺎح ]‪ [ENTER‬ﻳﺆدي اﻟﻰ اﻟـﻰ ﺗﻨﻔﻴـﺬ اﻻﻣـﺮ. ﺗﺴـﺘﻄﻴﻊ ﻋـﺮض‬
                   ‫هﺬﻩ اﻟﻨﺎﻓﺬة ﺑﺎﺧﺘﻴﺎر اﻻﻣﺮ ‪ Immediate Window‬ﻣﻦ ﻗﺎﺋﻤﺔ ‪.View‬‬

                                   ‫ﻧﺎﻓﺬة ﻣﺴﺘﻌﺮض اﻟﻜﺎﺋﻨﺎت ‪Object Browser‬‬
                                                                  ‫ا‬
‫اذا آﻨﺖ ﻣﺒﺘﺪءً ﻓﺈن هﺬﻩ اﻟﻨﺎﻓﺬة ﻟﻦ ﺗﺜﻴﺮ اهﺘﻤﺎﻣـﻚ، وﻟﻜـﻦ ﺑﻌـﺪ ان ﺗﺼـﻞ اﻟـﻰ ﻣﺮﺣﻠـﺔ‬
‫ﻣﺘﻘﺪﻣﺔ ﻣﻦ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪ Visual Basic‬ﺳـﻴﻜﻮن ﻟﻬـﺬﻩ اﻟﻨﺎﻓـﺬة ﺗﻘـﺪﻳﺮ آﺒﻴـﺮ. ﺗﻌـﺮض ﻟـﻚ‬
‫هﺬﻩ اﻟﻨﺎﻓﺬة ﺟﻤﻴﻊ اﻟﻔﺌﺎت اﻟﻤﻮﺟﻮدة ﻓﻲ اﻟﻤﻜﺘﺒﺎت اﻟﻤﻀﻤﻨﺔ ﻓـﻲ ﺑﺮﻧﺎﻣﺠـﻚ ﻣـﻊ آﺂﻓـﺔ‬
‫ﻃﺮﻗﻬﺎ، ﺧﺼﺎﺋﺼﻬﺎ واﺣﺪاﺛﻬﺎ ﻟﺘﻌﻄﻴﻚ ﻓﻜﺮة ﻋﺎﻣـﺔ ﻋـﻦ ﻣﺤﺘﻮﻳـﺎت هـﺬﻩ اﻟﻤﻜﺘﺒـﺎت. ﻣﻴـﺰة‬
‫اﺧﺮى اﺳﺘﺨﺪﻣﻬﺎ آﺜﻴﺮا هﻲ اﻧﻬﺎ ﺗﺴﻬﻞ ﻋﻠﻴﻚ ﻋﻤﻠﻴﺔ اﻳﺠﺎد ﺻﻔﺤﺔ اﻟﺘﻌﻠﻴﻤﺎت اﻟﺨﺎﺻﺔ‬
‫ﺑﺎﻻﻣﺮ اﻟﺬي ﺗﺮﻳﺪﻩ ﻋﻦ ﻃﺮﻳﻖ اﻟﻨﻘﺮ ﺑﺰر اﻟﻔﺄرة اﻻﻳﻤـﻦ ﻋﻠـﻰ اﻟﻌﻨﺼـﺮ اﻟﻤﻄﻠـﻮب واﺧﺘﻴـﺎر‬
‫اﻻﻣﺮ ‪ Help‬ﻣﻦ اﻟﻘﺎﺋﻤﺔ اﻟﻤﻨﺴﺪﻟﺔ. ﺗﺴﺘﻄﻴﻊ ﻋﺮض ﻧﺎﻓﺬة ﻣﺴﺘﻌﺮض اﻟﻜﺎﺋﻨـﺎت ﺑﺎﺧﺘﻴـﺎر‬
                ‫اﻻﻣﺮ ‪ Object Browser‬ﻣﻦ ﻗﺎﺋﻤﺔ ‪ View‬او اﻟﻀﻐﻂ ﻋﻠﻰ اﻟﻤﻔﺘﺎح ]2‪.[F‬‬
                                                 ‫8‬


                                        ‫ﻧﺎﻓﺬة اﻟﻤﺘﻐﻴﺮات اﻟﻤﺤﻠﻴﺔ ‪Local Window‬‬
‫اﻟﻐﺮض اﻟﺮﺋﻴﺴﻲ ﻣﻦ هﺬﻩ اﻟﻨﺎﻓﺬة ﻳﻈﻬﺮ ﻓﻲ وﻗﺖ اﻟﺘﻨﻔﻴﺬ ‪ ،Run Time‬ﻻﻧﻬﺎ ﻓﻲ وﻗـﺖ‬
‫اﻟﺘﺼﻤﻴﻢ ‪ Design Time‬ﻟـﻴﺲ ﻟﻬـﺎ أي وﻇﻴﻔـﺔ اﻳﺠﺎﺑﻴـﺔ ﻓـﻼ ﺗﻌﺮﺿـﻬﺎ ﺣﺘـﻰ ﻻ ﺗﺘـﺰاﺣﻢ‬
‫اﻟﻨﻮاﻓــﺬ اﻣﺎﻣــﻚ. ﺗﻌــﺮض ﻟــﻚ هــﺬﻩ اﻟﻨﺎﻓــﺬة ﻗــﻴﻢ ﺟﻤﻴــﻊ اﻟﻤﺘﻐﻴــﺮات اﻟﻤﺤﻠﻴــﺔ ‪Local‬‬
            ‫ـ‬        ‫ـ‬     ‫ـ‬                           ‫ـ‬      ‫ـ‬     ‫ـ‬
‫‪ Variables‬اﻟﻤﻮﺟ ـﻮد ﻓ ـﻲ اﻻﺟ ـﺮاء ‪ Procedure‬اﻟﺤــﺎﻟﻲ واﻟ ـﺬي ﻳ ـﺘﻢ ﺗﻨﻔﻴ ـﺬﻩ اذا ﻗﻤــﺖ‬
‫ﺑﻌﻤﻠﻴﺔ اﻻﻳﻘﺎف اﻟﻤﺆﻗﺖ ‪ Pause‬ﻟﻠﺒﺮﻧﺎﻣﺞ. ﻓﻲ ﺣﺎﻟﺔ وﺟﻮد آﺎﺋﻨﺎت ‪ Objects‬ﻣﺤﻠﻴﺔ ﻓﻲ‬
‫اﻻﺟﺮاء، ﻓﺎن اﺳﻢ اﻟﻜﺎﺋﻦ ﺳﻴﻈﻬﺮ ﻓﻲ اﻟﺠﺪول ﻣﻼﺻﻖ ﻟﻌﻼﻣﺔ اﻟﺰاﺋﺪ "+" ﺣﺘـﻰ ﺗﻘـﻮم‬
‫ﺑﺎﻟﻨﻘﺮ ﻋﻠﻴﻪ وﻳﻌﺮض ﻟـﻚ ﺟﻤﻴـﻊ اﻟﺨﺼـﺎﺋﺺ وﻗﻴﻤﻬـﺎ اﻟﺘﺎﺑﻌـﺔ ﻟﻬـﺬا اﻟﻜـﺎﺋﻦ. ﻟﻌـﺮض هـﺬﻩ‬
                                  ‫اﻟﻨﺎﻓﺬة اﺧﺘﺮ اﻻﻣﺮ ‪ Local Window‬ﻣﻦ اﻟﻘﺎﺋﻤﺔ ‪.View‬‬

 ‫وﻗﺖ اﻟﺘﻨﻔﻴﺬ ‪ Run Time‬هﻮ اﻟﻤﺮﺣﻠﺔ اﻟﺘﻲ ﻳﺘﻢ ﺗﻨﻔﻴﺬ ﺑﺮﻧﺎﻣﺠﻚ ﻓﻴﻬﺎ –‬             ‫ﻣﻼﺣﻈﺔ:‬
 ‫ﺑﻌـﺪ اﻟﻀـﻐﻂ ﻋﻠـﻰ اﻟﻤﻔﺘـﺎح ]5‪ ،[F‬اﻣـﺎ وﻗـﺖ اﻟﺘﺼـﻤﻴﻢ ‪Design Time‬‬
 ‫ﻓﻬﻲ اﻟﻤﺮﺣﻠﺔ اﻟﺘـﻲ ﺗﺼـﻤﻢ ﺑﺮﻧﺎﻣﺠـﻚ ﺑﻬـﺎ. ﻳﻮﺟـﺪ وﻗـﺖ ﺧـﺎص ﻳﻌـﺮف‬
 ‫ﺑﺎﻻﻳﻘﺎف اﻟﻤﺆﻗﺖ ‪ Pause Time‬او اﻟﻘﻄﻊ ‪ Break‬وهﻮ ﺑﺎﺧﺘﺼـﺎر ﻋﻤﻠﻴـﺔ‬
                   ‫اﻟﻮﻗﻒ اﻟﻤﺆﻗﺖ ﻟﺘﻨﻔﻴﺬ ﺑﺮﻧﺎﻣﺠﻚ وﻟﻜﻦ ﻟﻴﺲ اﻧﻬﺎﺋﻪ.‬

                                             ‫ﻧﺎﻓﺬة اﻟﻤﺮاﻗﺒﺔ ‪Watches Window‬‬
  ‫ـ‬        ‫ـ‬       ‫ـ‬   ‫ـ‬
‫ﺗﻤﻜﻨـﻚ هـﺬﻩ اﻟﻨﺎﻓـﺬة ﻣـﻦ ﻣﺮاﻗﺒـﺔ اﻟﻤﺘﻐﻴـﺮات او اﻟﻌﺒـﺎرات اﻟﺘـﻲ ﺗﻀـﻴﻔﻬﺎ ﺑﻬـﺎ. ﻋﻤﻠﻴـﺔ‬
                               ‫ـ‬                    ‫ـ‬       ‫ـ‬     ‫ـ‬       ‫ـ‬
‫اﻟﻤﺮاﻗﺒﺔ ﺗﻜﻮن ﻣﺘﻮاﺻﻠﺔ ودورﻳﺔ اﻟﺘﺤﺪﻳﺚ آﻮزارة اﻻﻋﻼم. ﺑﺎﻣﻜﺎﻧﻚ ﺗﺠﻤﻴﺪ ﻋﻤﻠﻴﺔ ﺗﻨﻔﻴـﺬ‬
‫اﻟﺒﺮﻧﺎﻣﺞ –اﻻﻳﻘﺎف اﻟﻤﺆﻗﺖ- ﻓﻲ ﺣﺎل آـﻮن ﻗﻴﻤـﺔ اﻟﻤﺘﻐﻴـﺮ اﺻـﺒﺤﺖ ﺻـﺤﻴﺤﺔ ‪ ،True‬او‬
‫ﻋﻨﺪ أي ﺗﻐﻴﻴﺮ ﻳﻄﺮأ ﻋﻠﻰ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ. اﻟﻬﺪف ﻣﻦ ﻧﺎﻓﺬة اﻟﻤﺮاﻗﺒﺔ ﻟﻴﺲ آﺎهﺪاف وزراة‬
    ‫ـ‬        ‫ـ‬         ‫ـ‬                       ‫ـ‬                ‫ـ‬      ‫ـ‬
‫اﻻﻋـﻼم، واﻧﻤـﺎ ﺗﺴـﻬﻴﻞ ﻋﻤﻠﻴـﺔ اﻟﺘﻨﻘـﻴﺢ ‪ Debugging‬وﻣﻌﺮﻓـﺔ ﻗـﻴﻢ اﻟﻤﺘﻐﻴـﺮات اﻟﺘـﻲ‬
‫ﺗﺸﻜﻞ ﻧﺴﺒﺔ 09% ﻣﻦ اﺳﺒﺎب ﺷﻮاﺋﺐ ‪ Bugs‬اﻟﺒﺮاﻣﺞ. ﻟﻌﺮض هﺬﻩ اﻟﻨﺎﻓﺬة اﺧﺘﺮ اﻻﻣـﺮ‬
‫‪ Watch Window‬ﻣـﻦ ﻗﺎﺋﻤـﺔ ‪ ،View‬وﻻﺿـﺎﻓﺔ ﻣﺘﻐﻴـﺮ او ﻗﻴﻤـﺔ ﻟﺠﻌﻠﻬـﺎ ﺧﺎﺿـﻌﺔ ﺗﺤـﺖ‬
‫اﻟﻤﺮاﻗﺒـﺔ، اﺧﺘـﺮ اﻻﻣـﺮ …‪ Add Watch‬ﻣـﻦ ﻗﺎﺋﻤـﺔ ‪– Debug‬وﻟـﻴﺲ ‪ -View‬او اﻧﻘـﺮ ﺑـﺰر‬
‫اﻟﻔﺄرة اﻻﻳﻤﻦ ﻋﻠﻰ اﻟﻨﺎﻓﺬة وﻣﻦ ﺛﻢ اﺧﺘﻴﺎر ﻧﻔﺲ اﻻﻣﺮ ﻣﻦ اﻟﻘﺎﺋﻤﺔ اﻟﻤﻨﺴـﺪﻟﺔ. اﻟﻤﻴـﺰة‬
‫اﻟﻤﻮﺟﻮدة ﻓﻲ هﺬﻩ اﻟﻨﺎﻓﺬة ﺗﻐﻄﻰ ﻋﻠﻰ اﻟﻘﺼﻮر اﻟﻤﻮﺟـﻮد ﻓـﻲ اﻟﻨﺎﻓـﺬة اﻟﺴـﺎﺑﻘﺔ، ﻻن‬
                              ‫هﺬﻩ اﻟﻨﺎﻓﺬة ﺗﺴﻤﺢ ﺑﺎﺿﺎﻓﺔ اﻟﻤﺘﻐﻴﺮات اﻟﻌﺎﻣﺔ ‪.Global‬‬

                                        ‫ﻧﺎﻓﺬة اﺳﺘﺪﻋﺎء اﻻﺟﺮاءات ‪Call Stack‬‬
‫ﺗﺘﺸﺎﺑﻪ هﺬﻩ اﻟﻨﺎﻓﺬة ﻣﻊ اﻟﻨﺎﻓﺬﺗﻴﻦ اﻟﺴﺎﺑﻘﺘﻴﻦ ﻓﻲ أﻧﻬﺎ ﻧﻮاﻓﺬ ﺧﺎﺻـﺔ ﺑـﺎﻟﺘﻨﻘﻴﺢ. ﺗﻌـﺮض‬
‫هﺬﻩ اﻟﻨﺎﻓﺬة ﻃﺎﺑﻮر ﻟﻼﺟﺮاءت اﻟﺘﻲ ﺳﻴﺘﻢ اﺳﺘﺪﻋﺎﺋﻬﺎ، ﺗﻔﻴﺪك هـﺬﻩ اﻟﻨﺎﻓـﺬة ﺑﻘـﻮة ﻓـﻲ‬
‫ﺣﺎﻟﺔ اﺳـﺘﺨﺪاﻣﻚ ﻟﻼﺳـﺘﺪﻋﺎءات اﻟﺘﺮاﺟﻌﻴـﺔ ‪ .Recursion‬اﺧﻴـﺮا، ﺑﺎﻣﻜﺎﻧـﻚ ﻋـﺮض هـﺬﻩ‬
                                              ‫9‬


‫اﻟﻨﺎﻓﺬة وﻗﺖ اﻻﻳﻘﺎف اﻟﻤﺆﻗﺖ ﻓﻲ ﺣﺎل وﺟﻮد اﺟﺮاءات ﻣﻨﺘﻈـﺮة اﻻﺳـﺘﺪﻋﺎء ﻋـﻦ ﻃﺮﻳـﻖ‬
      ‫اﻻﻣﺮ ‪ Call Stack‬اﻟﻤﻮﺟﻮد ﻓﻲ ﻗﺎﺋﻤﺔ ‪ View‬او اﻟﻀﻐﻂ ﻋﻠﻰ اﻟﻤﻔﺎﺗﻴﺢ ]‪.[Ctrl+L‬‬

                                                ‫ﻧﺎﻓﺬة ﻋﺮض اﻟﺒﻴﺎﻧﺎت ‪Data View‬‬
‫ﺗﺴﺘﻄﻴﻊ ﻋﺮض هﺬﻩ اﻟﻨﺎﻓﺬة ﻋﻦ ﻃﺮﻳﻖ اﺧﺘﻴﺎر اﻻﻣﺮ ‪ Data View Window‬ﻣـﻦ ﻗﺎﺋﻤـﺔ‬
‫‪ View‬او اﻟﻨﻘﺮ ﻋﻠﻰ رﻣﺰهﺎ ﻓـﻲ ﺷـﺮﻳﻂ اﻻدوات اﻟﻘﻴﺎﺳـﻲ ‪ .Standard Toolbar‬ﺗﻌﺘﺒـﺮ‬
‫ﻧﺎﻓﺬة ﻋﺮض اﻟﺒﻴﺎﻧﺎت اﺣﺪث ﻧﺎﻓﺬة دﺧﻠﺖ ﺻـﻨﺪوق ﺑﻴﺌـﺔ اﻟﺘﻄـﻮﻳﺮ اﻟﻤﺘﻜﺎﻣﻠـﺔ ‪ ،IDE‬ﻓﻠـﻢ‬
‫ﺗﻈﻬﺮ اﻻ ﻓﻲ اﻻﺻﺪار اﻻﺧﻴﺮ ﻣﻦ اﺻﺪارات ‪ Visual Basic‬وهـﻮ اﻟﺴـﺎدس. هـﺬﻩ اﻟﻨﺎﻓـﺬة‬
‫اﻟﺒﺴﻴﻄﺔ ﻓﻲ ﻣﻈﻬﺮهﺎ ﺗﻌﺘﺒﺮ اﻗﻮى ﻧﺎﻓﺬة ﻣﻦ اﻟﻨﻮاﻓﺬ اﻟﺘﻲ ذآﺮﺗﻬﺎ! ﻻﻧﻬﺎ –دون ﻣﺒﺎﻟﻐﺔ-‬
  ‫ـ‬        ‫ـ‬         ‫ـ‬
‫ﺗﻌﺘﺒـﺮ ﺑﺮﻧـﺎﻣﺞ آﺎﻣـﻞ ﻟﻤﺮاﻗﺒـﺔ، إﻧﺸـﺎء، ﺗﻌـﺪﻳﻞ، ﺣـﺬف وﻋـﺮض ﺟـﺪاول وﺣﻘـﻮل ﻗﻮاﻋـﺪ‬
                                     ‫ـ‬     ‫ـ‬     ‫ـ‬               ‫ـ‬       ‫ـ‬
    ‫اﻟﺒﻴﺎﻧﺎت ﺑﺎﺧﺘﻼف أﻧﻮاﻋﻬﺎ ﻣﺜﻞ: ‪ .... ORACLE ،MS-Access ،MS-SQL Server‬اﻟﺦ.‬
‫ﻟﺬﻟﻚ، ﻓﺎﻧﻪ ﻣﻦ اﻟﺒـﺪﻳﻬﻲ ان ﻻ ﻧﻀـﻴﻊ وﻗﺘﻨـﺎ وﻧﻔﺼـﻠﻬﺎ اﻻن، ﻓـﺎﻟﺠﺰء اﻟﺜـﺎﻧﻲ ﻣـﻦ اﺟـﺰاء‬
              ‫اﻟﻜﺘﺎب "ﺑﺮﻣﺠﺔ ﻗﻮاﻋﺪ اﻟﺒﻴﺎﻧﺎت" هﻮ اهﻞ ﻟﻠﺘﻔﺼﻴﻞ -واﻟﺘﻄﺮﻳﺰ اذا آﻨﺖ ﺗﺮﻳﺪ!‬

                                          ‫ﻗﻮاﺋﻢ ﺑﻴﺌﺔ اﻟﺘﻄﻮﻳﺮ اﻟﻤﺘﻜﺎﻣﻠﺔ‬
‫اذا ﺗﺤﺪﺛﺖ ﻋﻦ آﻞ اﻣﺮ ﻣـﻦ اواﻣـﺮ ﻗـﻮاﺋﻢ ﺑﻴﺌـﺔ اﻟﺘﻄـﻮﻳﺮ اﻟﻤﺘﻜﺎﻣﻠـﺔ ﻓـﻲ هـﺬﻩ اﻟﻔﻘـﺮة،‬
‫ﻓﺴﻴﻜﻮن اﻟﻜﺘﺎب اﺷﺒﻪ ﺑﻤﺮاﺟﻊ ‪ .MSDN‬ﻓﻴﺴﺘﺤﺴﻦ –ﻟﻲ وﻟﻚ- ان ﻳﺘﻢ ﺷـﺮح وﻇﻴﻔـﺔ‬
         ‫اﻻﻣﺮ ﻓﻲ ﺣﻴﻦ اﺳﺘﺨﺪاﻣﻪ، اﻻ اﻧﻨﻲ ﺳﺄﻋﺮﻓﻚ ﻋﻠﻰ اﻟﻘﻮاﺋﻢ ﺑﻄﺮﻳﻘﺔ ﻣﺒﺴﻄﺔ:‬

                                                                   ‫اﻟﻘﺎﺋﻤﺔ ‪:File‬‬
‫ﺗﺤﺘﻮي هﺬﻩ اﻟﻘﺎﺋﻤﺔ ﻋﻠـﻰ اواﻣـﺮ اﺳﺎﺳـﻴﺔ ﺧﺎﺻـﺔ ﻟﻠﻤﺸـﺎرﻳﻊ ﺑﺸـﻜﻞ ﻋـﺎم، آﺈﻧﺸـﺎء‬
‫ﻣﺸــﺮوع ﺟﺪﻳــﺪ، ﺣﻔــﻆ ﻣﺤﺘﻮﻳــﺎت اﻟﻤﺸــﺮوع، ﻃﺒﺎﻋــﺔ ﻣﺤﺘﻮﻳــﺎت اﻟﻤﺸــﺮوع وﺗﺮﺟﻤــﺔ‬
‫اﻟﻤﺸﺮوع وﺗﺤﻮﻳﻠﻪ اﻟﻰ ﻣﻠﻒ ﺛﻨﺎﺋﻲ ‪ .Binary‬اﻟﻤﻴﺰة اﻟﺘﻲ اﺿﻴﻔﺖ ﻟـ 6‪ VB‬هﻲ اﻣﻜﺎﻧﻴـﺔ‬
‫ﻓﺘﺢ اآﺜﺮ ﻣﻦ ﻣﺸﺮوع ﻓﻲ ﻧﺴﺨﺔ واﺣـﺪة ﻣـﻦ اﻟﺒﻴﺌـﺔ، وهـﻲ ﻣﻴـﺰة ﺗﻌـﺮف ﺑﺎﻟﻤﺸـﺎرﻳﻊ‬
                                                     ‫اﻟﻤﺘﻌﺪدة ‪.Multiple Projects‬‬

                                                                  ‫اﻟﻘﺎﺋﻤﺔ ‪:Edit‬‬
‫ﺗﺤﻮي هﺬﻩ اﻟﻘﺎﺋﻤﺔ ﻋﻠﻰ اواﻣﺮ اﻟﺘﺤﺮﻳﺮ اﻟﻘﻴﺎﺳﻴﺔ آﺎﻟﻘﺺ، اﻟﻨﺴـﺦ واﻟﻠﺼـﻖ. ﺑﺎﻻﺿـﺎﻓﺔ‬
‫اﻟﻰ اواﻣﺮ ﺧﺎﺻﺔ ﺑﻘﻮاﻋـﺪ اﻟﺒﻴﺎﻧـﺎت ﻓـﻲ ﺣﺎﻟـﺔ وﺟـﻮد ﻗﺎﻋـﺪة ﺑﻴﺎﻧـﺎت ﻓـﻲ ﻧﺎﻓـﺬة ﻋـﺮض‬
‫اﻟﺒﻴﺎﻧﺎت ‪ .Data View‬ﻣﻌﻈﻢ اﻻواﻣﺮ اﻟﻮاردة ﻓﻲ اﺳﻔﻞ هـﺬﻩ اﻟﻘﺎﺋﻤـﺔ ﺗﺴـﺘﺨﺪﻣﻬﺎ ﻣـﻊ‬
                                             ‫ﻧﺎﻓﺬة ﻣﺤﺮر اﻻآﻮاد ‪.Code Window‬‬
                                             ‫01‬


                                                                  ‫اﻟﻘﺎﺋﻤﺔ ‪:View‬‬
‫ذآﺮت ﻣﻌﻈﻢ ﻣﺤﺘﻮﻳﺎﺗﻬﺎ ﻓﻲ ﻓﻘﺮة "ﻧﻮاﻓﺬ ﺑﻴﺌـﺔ اﻟﺘﻄـﻮﻳﺮ اﻟﻤﺘﻜﺎﻣﻠـﺔ"، وﺑﺎﻻﻋﺘﻤـﺎد ﻋﻠـﻰ‬
                       ‫ﻧﺒﺎهﺘﻚ وﻣﺪى اﺳﺘﻌﻴﺒﺎك ﻳﻤﻜﻨﻚ ﻣﻌﺮﻓﺔ اﻟﻐﺮض هﺬﻩ اﻟﻘﺎﺋﻤﺔ.‬

                                                           ‫اﻟﻘﺎﺋﻤﺔ ‪:Project‬‬
‫ﻣﻌﻈﻢ اواﻣﺮهﺎ ﺧﺎﺻﺔ ﺑﻤﺤﺘﻮﻳﺎت اﻟﻤﺸﺎرﻳﻊ، ﻓﻬﻲ ﺗﻤﻜﻨﻚ ﻣﻦ اﺿـﺎﻓﺔ ﻋﻨﺼـﺮ او ﻋﻨﺎﺻـﺮ‬
‫ﻣﻦ ﻋﻨﺎﺻﺮ اﻟﻤﺸﺮوع آﻨﻮاﻓﺬ اﻟﻨﻤﺎذج ‪ ،Forms‬ﻣﻠﻔﺎت اﻟﺒﺮﻣﺠﺔ ‪ ،Module‬ﻓﺌﺎت ‪Classes‬‬
  ‫ـ‬      ‫ـ‬                     ‫ـ‬
‫.... اﻟـﺦ. اﻟﻤﺰﻳـﺪ اﻳﻀـﺎ، ﻳﻤﻜﻨـﻚ اﺿـﺎﻓﺔ ادوات ﺗﺤﻜـﻢ ‪ ActiveX Controls‬اﺿـﺎﻓﻴﺔ ﻋـﻦ‬
                                            ‫ـ‬    ‫ـ‬       ‫ـ‬     ‫ـ‬        ‫ـ‬
‫ﻃﺮﻳﻖ اﻻﻣﺮ ‪ Components‬او ﺗﻀﻤﻴﻦ ﻣﻜﺘﺒﺎت ‪ ActiveX DLL‬ﺧﺎرﺟﻴﺔ ﻋﻦ ﻃﺮﻳـﻖ اﻻﻣـﺮ‬
                                                                 ‫‪.References‬‬

                                                             ‫اﻟﻘﺎﺋﻤﺔ ‪:Format‬‬
‫اﻻواﻣﺮ اﻟﻤﻮﺟﻮدة ﻓﻲ هﺬﻩ اﻟﻘﺎﺋﻤﺔ ﺧﺎﺻﺔ ﺑﺘﻨﺴﻴﻖ اﻻدوات اﻟﺘـﻲ ﺗﻀـﻌﻬﺎ ﻋﻠـﻰ ﻧﺎﻓـﺬة‬
‫اﻟﻨﻤﻮذج ﻣﻦ ﻧﺎﺣﻴﺔ ﻣﻮﻗﻌﻬﺎ ﻋﻠﻰ اﻟﻨﺎﻓﺬة، ﻓﺘﻮﺟﺪ اواﻣﺮ ﻣﺮﻧﺔ ﺗـﻮﻓﺮ ﻋﻠﻴـﻚ ﺟﻬـﺪ ﻣﺤـﺎذاة‬
‫اﻻدوات او ﺗﻮﺳﻴﻄﻬﺎ ﻋﻠﻰ اﻟﻨﺎﻓﺬة، ﺑﺎﻻﺿﺎﻓﺔ اﻟﻰ ﺗﻐﻴﻴﺮ ﺗﺮﺗﻴﺐ ﻇﻬـﻮر اﻻدوات أي وﺿـﻊ‬
‫أداة ﻓﻮق اﻟﻜﻞ او أداة ﺧﻠـﻒ اﻟﻜـﻞ. اﻻﻣـﺮ اﻻﺧﻴـﺮ ‪ Lock Controls‬ﺗﺴـﺘﺨﺪﻣﻪ اذا آﻨـﺖ‬
‫راﺿﻴﺎ ﻋﻦ ﺗﺼﻤﻴﻢ اﻻدوات وﺗﻮد ﻣﻨﻊ ﻧﻔﺴﻚ ﻣﻦ ﺗﻐﻴﻴـﺮ اﺣﺠﺎﻣﻬـﺎ او ﻣﻮاﻗﻌـﺎ ﻋـﻦ ﻃﺮﻳـﻖ‬
        ‫اﻟﺨﻄﺄ، هﺬا اﻟﻘﻔﻞ ﺗﺴﺘﻄﻴﻊ ﻓﺘﺤﺔ ﺑﻜﻞ ﺑﺴﺎﻃﺔ ﺑﺎﺧﺘﻴﺎر ﻧﻔﺲ اﻻﻣﺮ ﻣﺮة اﺧﺮى.‬

                                                            ‫اﻟﻘﺎﺋﻤﺔ ‪:Debug‬‬
‫ﻣﻌﻈﻢ اواﻣﺮ اﻟﺘﻨﻘﻴﺢ وﺿﻌﺖ اﺳﻔﻞ هﺬﻩ اﻟﻘﺎﺋﻤﺔ. ﻣﻦ هﺬﻩ اﻻواﻣﺮ اﺧﺘﻴﺎر ﻃﺮﻳﻘﺔ ﺗﻨﻔﻴـﺬ‬
‫اﻟﺒﺮﻧﺎﻣﺞ، آﺘﻨﻔﻴﺬ ﺳﻄﺮ واﺣـﺪ ﻣﻨـﻪ ‪ ،Step Into‬اﺟـﺮاء آﺎﻣـﻞ ‪ ،Step Over‬اﻣـﺮ ﺳـﺎﺑﻖ‬
‫‪ Step Out‬او اﻟﺘﻨﻔﻴﺬ ﺣﺘﻰ اﻟﻮﺻﻮل اﻟﻰ اﻟﺴﻄﺮ اﻟﺬي ﻳﻮﺟﺪ ﻋﻠﻴﻪ ﻣﺆﺷﺮ اﻟﻜﺘﺎﺑـﺔ ‪Run‬‬
‫‪ .to Cursor‬وﺑﺎﻟﻨﺴﺒﺔ ﻟﻨﻘﺎط اﻟﻘﻄﻊ ‪ BreakPoints‬ﻓﻬﻲ ﻋﻼﻣـﺎت ﺗﻈﻬـﺮ ﻣﺒـﺪﺋﻴﺎ ﺑـﺎﻟﻠﻮن‬
‫اﻻﺣﻤﺮ ﻋﻠﻰ ﺳﻄﺮ ﻣﻌﻴﻦ ﺑﺤﻴﺚ ﺗﺘﻢ ﻋﻤﻠﻴـﺔ اﻻﻳﻘـﺎف اﻟﻤﺆﻗـﺖ ﻟﻠﺒﺮﻧـﺎﻣﺞ ﻋﻨـﺪ اﻟﻮﺻـﻮل‬
                                                           ‫اﻟﻰ هﺬﻩ اﻟﻌﻼﻣﺎت.‬

                                                                 ‫اﻟﻘﺎﺋﻤﺔ ‪:Run‬‬
‫ﻋﻦ ﻃﺮﻳﻖ هﺬﻩ اﻟﻨﺎﻓﺬة اﻟﺒﺴﻴﻄﺔ ﺗﺴﺘﻄﻴﻊ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ وﺗﺘﻤﻜﻨﻚ ﻣﻦ اﺧﺘﻴﺎر اﻻواﻣـﺮ‬
‫اﻻﺧﺮى آﺎﻻﻳﻘﺎف اﻟﻤﺆﻗﺖ ‪ Break‬او اﻧﻬﺎء ﻋﻤﻠﻴﺔ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧـﺎﻣﺞ ‪ .End‬ﺑﺎﻟﻨﺴـﺒﺔ ﻟﻼﻣـﺮ‬
‫‪ Start with Full Compile‬هﻮ ﻣﺸﺎﺑﻪ ﻻﻣﺮ اﻟﺘﻨﻔﻴﺬ ‪ Start‬وﻟﻦ ﺗﺤﺘﺎﺟـﻪ اﻻ ﻓـﻲ ﺣـﺎﻻت‬
                                            ‫ﻧﺎدرة ﺳﺘﺠﺪهﺎ ﻻﺣﻘﺎ ﻓﻲ هﺬا اﻟﻜﺘﺎب.‬
                                             ‫11‬


                                                            ‫اﻟﻘﺎﺋﻤﺔ ‪:Query‬‬
‫هــﺬﻩ اﻟﻘﺎﺋﻤــﺔ ﺟﺪﻳــﺪة ﻋﻠــﻰ ﻣﺒﺮﻣﺠــﻲ 5‪ VB‬وهــﻲ ﻣﺘــﻮﻓﺮة ﻟﻨﺴــﺨﺔ اﻟﻤﺤﺘــﺮﻓﻴﻦ‬
          ‫ـ‬      ‫ـ‬                          ‫ـ‬
‫‪ Professional Edition‬واﻟﻤﺆﺳﺴـﺎت ‪ Enterprise Edition‬ﻟﻼﺻـﺪار اﻟﺴـﺎدس 6‪.VB‬‬
‫اواﻣﺮ هﺬﻩ اﻟﻘﺎﺋﻤﺔ ﻏﻴﺮ ﻣﻤﻜﻨﺔ ﺣﺘـﻰ ﺗﻨﺸـﺊ ﺟﻤﻠـﺔ اﺳـﺘﻌﻼم ‪ SQL‬ﺑﺎﺳـﺘﺨﺪام اﻷداة‬
                                                  ‫‪.Microsoft Query Builder‬‬

                                                          ‫اﻟﻘﺎﺋﻤﺔ ‪:Diagram‬‬
‫اﻳﻀﺎ هﺬﻩ ﻗﺎﺋﻤﺔ ﺟﺪﻳﺪة ﻋﻠﻰ ﻣﺒﺮﻣﺠﻲ 5‪ VB‬وﻣﺘـﻮﻓﺮة ﻟـﻨﻔﺲ اﻟﻨﺴـﺦ اﻟﻤـﺬآﻮرة ﻓـﻲ‬
‫اﻟﻔﻘﺮة اﻟﺴﺎﺑﻘﺔ. اواﻣﺮ هﺬﻩ اﻟﻘﺎﺋﻤﺔ ﻏﻴﺮ ﻣﻤﻜﻨﺔ اﻻ ﻓﻲ ﺣﺎﻟﺔ ﺗﻌﺎﻣﻠﻚ ﻣﻊ ﻗﺎﻋﺪة ﺑﻴﺎﻧـﺎت‬
                                                      ‫‪ SQL Server‬او ‪.ORACLE‬‬

                                                                 ‫اﻟﻘﺎﺋﻤﺔ ‪:Tools‬‬
‫ﺗﺤﺘﻮي ﻋﻠﻰ اواﻣﺮ ﻣﺨﺘﻠﻔـﺔ اﻟﺘﺼـﺎﻧﻴﻒ آﻤﺤـﺮر اﻟﻘـﻮاﺋﻢ ‪ Menu Editor‬وﻣﺴـﻬﻞ آﺘﺎﺑـﺔ‬
‫اﻻﺟﺮاءات ‪ Add Procedure‬وﻏﻴﺮهﺎ... اذا ادرت ﺗﺨﺼﻴﺺ ﺑﻴﺌـﺔ اﻟﺘﻄـﻮﻳﺮ اﻟﻤﺘﻜﺎﻣﻠـﺔ ‪IDE‬‬
  ‫ـ‬     ‫ـ‬   ‫ـ‬
‫ﻓـﺎﻻﻣﺮ ‪ Options‬ﻳﻤﻜﻨـﻚ ﻣـﻦ اﻟﻮﺻـﻮل اﻟـﻰ ﺻـﻨﺪوق اﻟﺤـﻮار ‪ Options‬اﻟـﺬي ﻳـﻮﻓﺮ ﻟـﻚ‬
                            ‫ـ‬              ‫ـ‬    ‫ـ‬       ‫ـ‬   ‫ـ‬
                        ‫ﻋﺸﺮات اﻟﺨﻴﺎرات واﻟﺨﺎﺻﺔ ﺑﺘﻐﻴﻴﺮ اﻋﺪادات ﺑﻴﺌﺔ اﻟﺘﻄﻮﻳﺮ ‪.IDE‬‬

                                                             ‫اﻟﻘﺎﺋﻤﺔ ‪:Add-Ins‬‬
‫اﻻواﻣﺮ اﻟﻤﻮﺟﻮدة ﻓﻲ هﺬﻩ اﻟﻘﺎﺋﻤﺔ ﻋﺒﺎرة ﻋﻦ ﺑﺮاﻣﺞ ﻣﺴﺘﻘﻠﺔ ﺗﺴﻤﻰ اﻻﺿـﺎﻓﺎت -‪Add‬‬
‫‪ Ins‬هﺪﻓﻬﺎ ﺗﻮﻓﻴﺮ ﺧﺪﻣﺎت اﺿﺎﻓﻴﺔ ﻟﺒﻴﺌﺔ اﻟﺘﻄﻮﻳﺮ ﺗﺰﻳﺪ ﻣﻦ ﻣﺮوﻧﺘﻬﺎ. ﺗﻄﻮﻳﺮ هﺬا اﻟﻨﻮع ﻣـﻦ‬
                                                       ‫اﻟﺒﺮاﻣﺞ ﺧﺎرج ﻧﻄﺎق اﻟﻜﺘﺎب.‬

                                                           ‫اﻟﻘﺎﺋﻤﺔ ‪:Window‬‬
‫اذا آﻨﺖ ﺑﺤﺎﺟﺔ اﻟﻰ ﺷﺮح ﻣﺤﺘﻮﻳﺎت هﺬﻩ اﻟﻘﺎﺋﻤﺔ، ﻓﻴﺒﺪو اﻧﻚ ﺟﺪﻳﺪ ﻟﻴﺲ ﻋﻠﻰ ‪Visual‬‬
‫‪ Basic‬ﻓﺤﺴﺐ واﻧﻤﺎ ﻋﻠﻰ ﺟﻤﻴﻊ ﺗﻄﺒﻴﻘﺎت ﺑﻴﺌﺔ ‪ ،Windows‬ﻓﺎﻓﻀﻞ ﺷﺮح اﺳـﻄﺮﻩ ﻟـﻚ‬
‫هﻮ ﺑﺎن ﺗﻮﻗﻒ ﻗﺮاءة اﻟﻜﺘﺎب –اﻻﻳﻘﺎف اﻟﻤﺆﻗﺖ- ﻓﻲ اﻟﺤﺎل، وﺗﺤﺎول اﻟﺘﻌـﺮف ﻋﻠـﻰ ﺑﻴﺌـﺔ‬
                                       ‫‪ Windows‬وﻣﻦ ﺛﻢ ﺗﻌﻮد ﻟﻤﺘﺎﺑﻌﺔ اﻟﻘﺮاءة.‬

                                                            ‫اﻟﻘﺎﺋﻤﺔ ‪:Help‬‬
‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻤﺴﺘﺨﺪﻣﻲ اﻻﺻﺪار اﻟﺴﺎدس ﻣﻦ ‪ ،Visual Basic‬ﻓﻠﻦ ﻳﺘﻤﻜﻨﻮا ﻣﻦ اﻟﻮﺻـﻮل‬
‫اﻟﻰ اﻟﺘﻌﻠﻴﻤﺎت اﻟﻔﻮرﻳﺔ اﻻ ﻓﻲ ﺣﺎﻟﺔ اﻧﺰال ﻧﺴـﺨﺔ ﻣـﻦ ﻣﻜﺘﺒـﺔ ‪Microsoft Developer‬‬
                                         ‫‪ Network‬واﻟﻤﺄﻟﻮﻓﺔ ﺑﺎﻻﺧﺘﺼﺎر ‪.MSDN‬‬
                                             ‫21‬


                                                          ‫اﺷﺮﻃﺔ اﻻدوات‬
‫ﺟﻤﻴﻊ اﻻزرار اﻟﻤﻮﺟﻮدة ﻓﻲ اﺷﺮﻃﺔ اﻻدوات ﻣﻨﺴﻮﺧﺔ ﻣﻦ اﻟﻘﻮاﺋﻢ اﻟﺴـﺎﺑﻘﺔ، ﻓﻼﻳﻮﺟـﺪ‬
  ‫ـ‬      ‫ـ‬      ‫ـ‬        ‫ـ‬    ‫ـ‬
‫داﻋـﻲ ﻻﻋـﺎدة اﻟﺸـﺮح. اﻣـﺎ اﻟﻐـﺮض ﻣـﻦ ﻧﺴـﺨﻬﺎ ﻓﻬـﻮ ﺗﺴـﺮﻳﻊ ﻋﻤﻠﻴـﺔ اﺧﺘﻴـﺎر اﻻﻣـﺮ.‬
                                     ‫ـ‬    ‫ـ‬     ‫ـ‬    ‫ـ‬      ‫ـ‬       ‫ـ‬      ‫ـ‬
‫ﺗﺴﺘﻄﻴﻊ اﻟﺘﺤﻜﻢ ﻓﻲ اﺷﺮﻃﺔ اﻻدوات وﺗﺤﺮﻳﺮهﺎ آﻤـﺎ ﺗﻔﻌـﻞ ﻣـﻊ ﺗﻄﺒﻴﻘـﺎت ‪MS-Office‬‬
‫ﺑﺎﻟﻀﻐﻂ ﺑﺰر اﻟﻔﺄرة اﻻﻳﻤﻦ ﻋﻠﻰ ﺷﺮﻳﻂ اﻻدوات واﺧﺘﻴﺎر اﻻﻣـﺮ ‪ Customize‬ﻣـﻦ اﻟﻘﺎﺋﻤـﺔ‬
‫اﻟﻤﻨﺴﺪﻟﺔ. اﺣﺐ ان اﻧﻮﻩ هﻨﺎ ﺑﺎن ﺻـﻨﺪوق اﻻدوات ‪ ToolBox‬ﻗـﺪ ادرﺟﺘـﻪ ﺿـﻤﻦ ﻓﻘـﺮة‬
   ‫ﻧﻮاﻓﺬ ﺑﻴﺌﺔ اﻟﺘﻄﻮﻳﺮ، ﻓﻼ ﺗﻌﺘﻘﺪ اﻧﻪ ﻣﻦ ﻓﺌﺔ اﺷﺮﻃﺔ اﻻدوات رﻏﻢ اﻟﺸﺒﻪ اﻟﻜﺒﻴﺮ ﺑﻴﻨﻬﻢ.‬


                                                        ‫آﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺠﻚ اﻻول‬
‫ﻻﺷﻚ ان اﻟﻤﻤﺎرﺳﺔ واﻟﺘﻄﺒﻴﻖ اﺣﺪ اهﻢ ﻋﻮاﻣﻞ ﺗﻌﻠـﻢ ﻟﻐـﺎت اﻟﺒﺮﻣﺠـﺔ، واﻟﻔﺼـﻞ اﻻول‬
 ‫ـ‬                     ‫ـ‬              ‫ـ‬            ‫ـ‬            ‫ـ‬
‫ﻣـﻦ هـﺬا اﻟﻜﺘـﺎب ﺳـﻴﺒﺪأ ﻣﻌـﻚ اﻟﻤﻤﺎرﺳـﺔ ﻟـﻴﺲ ﻓﻘـﻂ ﻟﻜﺘﺎﺑـﺔ ﺑﺮﻧﺎﻣﺠـﻚ اﻻول، واﻧﻤـﺎ‬
‫ﻟﺘﻮﺿﻴﺢ اﻟﻤﺮاﺣﻞ واﻟﺨﻄﻮات اﻟﺴـﻠﻴﻤﺔ ﻟﻌﻤﻠﻴـﺔ ﺑﻨـﺎء اﻟﺒـﺮاﻣﺞ ﺳـﻮاء آﺎﻧـﺖ ﺷﺨﺼـﻴﺔ او‬
                                                                        ‫ﺗﺠﺎرﻳﺔ.‬

                                       ‫اﻟﺨﻄﻮة اﻻوﻟﻰ: ﻓﻜﺮة اﻟﺒﺮﻧﺎﻣﺞ‬
‫ﻗﻜﺮة اﻟﺒﺮﻧﺎﻣﺞ ﻟﻴﺴﺖ ﻟﻬﺎ ﻋﻼﻗﺔ ﺑـ ‪ Visual Basic‬وﻻ ﺑﺎي ﻟﻐـﺔ اﺧـﺮى وﻻ ﺣﺘـﻰ ﺑﻨﻈـﺎم‬
‫اﻟﺘﺸﻐﻴﻞ. ﻓﻤﻦ اﻟﺒﺪﻳﻬﻲ اﻧﻚ ﻗﺒﻞ ان ﺗﻜﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻋﻠﻴﻚ ﻣﻌﺮﻓـﺔ ﻣـﺎ اﻟـﺬي ﺗﺮﻳـﺪﻩ ﻣـﻦ‬
‫اﻟﺒﺮﻧﺎﻣﺞ. ﻗﺪ ﺗﺄﺗﻴﻚ ﻓﻜﺮة ﺑﺮﻧﺎﻣﺞ ﺑﻴﻨﻤـﺎ ﺗﻘﻠـﺐ ﺻـﻔﺤﺎت اﻟﻜﺘـﺎب او ﻣﺘـﺄﻣﻼ اﻟﻨﺠـﻮم ﻓـﻲ‬
‫وﺿﺢ اﻟﻨﻬﺎر، وﻗﺪ ﺗﻜﻮن اﻟﻔﻜﺮة اﻟﺰاﻣﻴـﺔ ﻋﻠﻴـﻚ آﺤـﻞ ﻣﺸـﻜﻠﺔ ﺗﺼـﺎدﻓﻚ ﻓـﻲ ﺟﻬـﺎزك او‬
                                                          ‫ﻣﺸﺮوع ﺗﺨﺮج ﺟﺎﻣﻌﻲ.‬
‫ﺑﻌﺪ ان ﺗﺨﻄﺮ اﻟﻔﻜﺮة ﻓﻲ ﺑﺎﻟﻚ وﺗﻈﻬﺮ ﻟﻤﺒﺔ ﻣﻀﻴﺌﺔ ﻓﻮق رأﺳﻚ، اﺳﺤﺐ اﻟﻠﻤﺒﺔ ورآﺒﻬـﺎ‬
‫ﻓﻲ اﻻﺑﺠﻮرة اﻟﻤﺠﺎورة ﻟﺠﻬﺎزك، ﺣﺘﻰ ﺗﺮآـﺰ وﺗﻘـﻮم ﺑﻌﻤﻠﻴـﺔ اﻟﺘﺨﻄـﻴﻂ ﻟﺘﻄﺒﻴـﻖ اﻟﻔﻜـﺮة‬
‫آﺒﺮﻧﺎﻣﺞ ﻳﺼﻤﻢ –ﻋﻠﻰ اﻻرﺟـﺢ- ﺑــ ‪ ،Visual Basic‬ﺣـﺪد اﻟﻤﺘﻄﻠﺒـﺎت واﻟﻤﺸـﺎآﻞ اﻟﺘـﻲ‬
‫ﺳﺘﺼــﺎدﻓﻚ. ﻣﺜــﻞ هــﺬﻩ اﻻﻣــﻮر ﺗﻨــﺪرج ﺗﺤــﺖ ﻋﻠــﻢ هﻨﺪﺳــﺔ اﻟﺒــﺮاﻣﺞ ‪Software‬‬
‫‪ Engineering‬واﻟﺘﺤﺪث ﻋﻨﻬﺎ ﺧﺎرج ﻧﻄﺎق اﻟﻜﺘﺎب. ﻟﺬﻟﻚ، ﺳﺎﺧﺘﻢ هﺬﻩ اﻟﻔﻘـﺮة ﺑـﺎﻟﻔﻜﺮة‬
     ‫اﻟﺘﻲ ﺳﻨﻘﻮم ﺑﺘﻨﻔﻴﺬهﺎ وهﻲ ﻋﺒﺎرة ﻋﻦ ﺑﺮﻧﺎﻣﺞ ﻳﺠﺮي ﻋﻤﻠﻴﺔ اﻟﻀﺮب ﺑﻴﻦ ﻋﺪدﻳﻦ.‬

                                     ‫اﻟﺨﻄﻮة اﻟﺜﺎﻧﻴﺔ: إﻧﺸﺎء اﻟﻤﺸﺮوع‬
‫ﺑﻌﺪ ﺗﺤﺪﻳﺪ ﻓﻜﺮة اﻟﺒﺮﻧﺎﻣﺞ وﺗﻮﺿﻴﺢ اﻟﻤﺘﻄﻠﺒـﺎت ﺳـﻨﺒﺪأ ﺑﺈﻧﺸـﺎء ﻣﻠﻔـﺎت اﻟﻤﺸـﺮوع. ﻗـﻢ‬
‫ﺑﺎﺧﺘﻴﺎر اﻻﻣﺮ ‪ New Project‬ﻣﻦ ﻗﺎﺋﻤﺔ ‪ File‬ﺛﻢ ﺣﺪد اﻟﻨﻮع ‪ .Standard EXE‬هـﺬا اﻟﻨـﻮع‬
                                                ‫31‬


‫ﻣﻦ اﻟﻤﺸﺎرﻳﻊ هﻲ ﻣﺸﺎرﻳﻊ ﺑﻨﺎء ﺑـﺮاﻣﺞ ﻗﻴﺎﺳـﻴﺔ ﺗﻌﻤـﻞ ﺗﺤـﺖ ﺑﻴﺌـﺔ ‪ ،Windows‬وﻋﻨـﺪ‬
                                          ‫اﻟﺘﺮﺟﻤﺔ ﺗﻜﻮن ﻣﻠﻔﺎﺗﻬﺎ ﻣﻦ اﻟﻨﻮع ‪.EXE‬‬
‫ﺑﻌﺪ ﻗﻴﺎﻣﻚ ﺑﻌﻤﻠﻴﺔ إﻧﺸﺎء اﻟﻤﺸﺮوع اﻟﺠﺪﻳﺪ، ﻗﻢ ﺑﻜﺘﺎﺑﺔ اﺳﻢ ﻣﻨﺎﺳـﺐ ﻟﻠﻤﺸـﺮوع ﻓـﻲ‬
                       ‫ـ‬        ‫ـ‬     ‫ـ‬    ‫ـ‬                           ‫ـ‬
‫ﺧﺎﻧـﺔ اﻟـﻨﺺ ‪ Project Name‬اﻟﻤﻮﺟـﻮدة ﻓـﻲ ﺻـﻨﺪوق اﻟﺤـﻮار …‪Project Properties‬‬
‫واﻟﺬي ﺗﺼﻞ اﻟﻴـﻪ ﺑﺎﺧﺘﻴـﺎر اﻻﻣـﺮ ‪ Project1 Properties‬ﻣـﻦ ﻗﺎﺋﻤـﺔ ‪ .View‬اآﺘـﺐ اﺳـﻢ‬
                                    ‫اﺑﺘﺪاﺋﻲ ﻟﻠﻤﺸﺮوع وﻟﻴﻜﻦ ‪.MyFirstProgram‬‬

 ‫ﻳﻜﻮن ﻋﻨﻮان اﻻﻣﺮ اﻟﺴﺎﺑﻖ ﻣﺨﺘﻠﻒ ﻣﻦ اﺳﻢ ﻣﺸﺮوع اﻟـﻰ ﺁﺧـﺮ. ﻓﺒﻌـﺪ‬               ‫ﻣﻼﺣﻈﺔ:‬
 ‫ﺗﻌـﺪﻳﻠﻚ ﻻﺳـﻢ اﻟﻤﺸـﺮوع، ﺳـﻴﻜﻮن ﻋﻨـﻮان اﻻﻣـﺮ ‪MyFirstProgram‬‬
                                              ‫…‪.Properties‬‬

‫اﺧﺘﺮ اﻻﻣﺮ ‪ Save Project‬ﻣﻦ ﻗﺎﺋﻤﺔ ‪ File‬ﻟﺤﻔﻆ ﻣﻠﻔﺎت اﻟﻤﺸـﺮوع، ﺗـﺬآﺮ ان اﻟﻤﺸـﺮوع‬
‫ﻳﺤﺘﻮي ﻋﻠﻰ ﻋﺪة ﻣﻠﻔﺎت ﻟﺬﻟﻚ ﻳﻔﻀﻞ اﻧﺸﺎء ﻣﺠﻠـﺪ ‪ Folder‬ﺧـﺎص ﺑﻤﻠﻔـﺎت اﻟﻤﺸـﺮوع‬
‫ﻗﺒﻞ ﺣﻔﻈﻪ. ﻣﻠﻒ اﻟﻤﺸﺮوع اﻟﺮﺋﻴﺲ ﻳﻜﻮن اﻣﺘـﺪادﻩ ‪ ،VBP‬اﻣـﺎ اﻟﻤﻠﻔـﺎت اﻻﺧـﺮى ﻓﻬـﻲ‬
  ‫ـ‬             ‫ـ‬          ‫ـ‬
‫ﻋﻨﺎﺻ ـﺮ ﻣﻜﻮﻧ ـﺔ ﻟﻠﻤﺸ ـﺮوع آﻨﻮاﻓ ـﺬ اﻟﻨﻤ ـﺎذج ‪ ،*.FRM‬ﻣﻠﻔ ـﺎت اﻟﺒﺮﻣﺠ ـﺔ ‪ ،*.BAS‬ﻣﻠﻔ ـﺎت‬
                                           ‫ـ‬       ‫ـ‬          ‫ـ‬         ‫ـ‬     ‫ـ‬
                                                              ‫اﻟﻔﺌﺎت ‪ .... *.CLS‬اﻟﺦ.‬

                                        ‫اﻟﺨﻄﻮة اﻟﺜﺎﻟﺜﺔ: ﺗﺼﻤﻴﻢ اﻟﻮاﺟﻬﺔ‬
      ‫ـ‬     ‫ـ‬        ‫ـ‬         ‫ـ‬
‫ﺑﻤ ـﺎ ان ‪ Visual Basic‬ﻳﻨ ـﺪرج ﺗﺤ ـﺖ ﺻ ـﻨﻒ ﻟﻐ ـﺎت اﻟﺒﺮﻣﺠ ـﺔ اﻟﻤﺮﺋﻴ ـﺔ، ﻓﻌﻤﻠﻴ ـﺔ ﺗﺼ ـﻤﻴﻢ‬
                                          ‫ـ‬     ‫ـ‬     ‫ـ‬     ‫ـ‬                     ‫ـ‬
‫اﻟﻮاﺟﻬﺔ ﺗﺘﻢ ﻓﻲ اﻟﻐﺎﻟﺐ ﺑﺎﺳﺘﺨﺪام اﻟﻔﺄرة. ﻧﺒﺪأ ﻓﻲ اﻟﻌﺎدة ﺑﻮﺿﻊ اﻻدوات ﻋﻠـﻰ ﻧﺎﻓـﺬة‬
‫اﻟﻨﻤﻮذج وﻣﻦ ﺛـﻢ ﺗﻌـﺪﻳﻞ ﺧﺼﺎﺋﺼـﻬﺎ. ﻋﻤﻠﻴـﺔ وﺿـﻊ اﻻدوات ﻋﻠـﻰ ﻧﺎﻓـﺬة اﻟﻨﻤـﻮذج ﺗـﺘﻢ‬
‫ﺑﺸﻜﻞ ﻣﺸﺎﺑﻪ ﻟﺮﺳﻢ اﻟﻤﺮﺑﻌﺎت ﻓﻲ ﺑﺮاﻣﺞ اﻟﺮﺳﻢ، واذا آﻨﺖ ﺗﻮاﺟﻪ ﺻﻌﻮﺑﺔ ﻓﻲ ﻋﻤـﻞ‬
                             ‫ذﻟﻚ، ﻓﺪرب ﻧﻔﺴﻚ ﺑﻀﻊ دﻗﺎﺋﻖ ﻋﻠﻰ ﺑﺮﻧﺎﻣﺞ اﻟﺮﺳﺎم ‪.Paint‬‬
‫اﻧﺘﻘــــﻞ اﻟــــﻰ ﺻــــﻨﺪوق اﻻدوات ‪ ToolBox‬وﺿــــﻊ أداة ﻋﻨــــﻮان ‪ Label‬و زر اواﻣــــﺮ‬
‫‪ CommandButton‬واداﺗــﻲ ‪ TextBoxes‬واﻷداة ‪ Line‬ﻟﺮﺳــﻢ اﻟﺨــﻂ، وﻣــﻦ ﺛــﻢ رﺗــﺐ‬
                                                  ‫اﻻدوات ﺑﺸﻜﻞ ﻣﺸﺎﺑﻪ ﻟﻠﺸﻜﻞ 1-3:‬




                                ‫ﺷﻜﻞ 1-3: واﺟﻬﺔ اﻟﻨﺎﻓﺬة اﻟﺮﺋﻴﺴﺔ ﻟﺒﺮﻧﺎﻣﺠﻚ اﻻول.‬
                                                 ‫41‬


‫ﺑﻌﺪ ﺗﺮﺗﻴﺐ اﻻدوات وﻣﺤﺎذاﺗﻬﺎ ﺳﻨﺒﺪأ ﺑﻌﻤﻠﻴﺔ ﺗﻌﻴﻴﻦ ﺧﺼﺎﺋﺼﻬﺎ. ﺣﺪد اﻷداة ﺑﺎﻟﻨﻘﺮ ﻋﻠﻴﻬﺎ‬
‫واﻧﺘﻘﻞ اﻟـﻰ ﻧﺎﻓـﺬة اﻟﺨﺼـﺎﺋﺺ وﻗـﻢ ﺑﺘﻌـﺪﻳﻞ ﻗـﻴﻢ ﺧﺼـﺎﺋﺺ اﻻدوات آﻤـﺎ ﻓـﻲ اﻟﺠـﺪول‬
                                                                      ‫اﻟﺘﺎﻟﻲ:‬

                                ‫اﻟﻘﻴﻤﺔ‬                ‫اﻟﺨﺎﺻﻴﺔ‬                 ‫اﻻداة‬
                              ‫‪frmMain‬‬                   ‫‪Name‬‬           ‫ﻧﺎﻓﺬة اﻟﻨﻤﻮذج‬
                        ‫"اﻟﺒﺮﻧﺎﻣﺞ اﻻول"‬                ‫‪Caption‬‬
                          ‫‪cmdMultiply‬‬                   ‫‪Name‬‬                 ‫زر اﻻواﻣﺮ‬
                                ‫"اﺿﺮب"‬                 ‫‪Caption‬‬
                            ‫‪lblProduct‬‬                  ‫‪Name‬‬               ‫أداة اﻟﻌﻨﻮان‬
                                    ‫"0"‬                ‫‪Caption‬‬
                                ‫‪txtFirst‬‬                ‫‪Name‬‬               ‫أداﺗﻲ اﻟﻨﺺ‬
                                    ‫"0"‬                ‫‪Caption‬‬
                            ‫‪txtSecond‬‬                   ‫‪Name‬‬
                                    ‫"0"‬                ‫‪Caption‬‬

 ‫ﻣﻦ ﺗﻘﺎﻟﻴﺪ ﻣﺒﺮﻣﺠﻲ ‪ Visual Basic‬آﺘﺎﺑﺔ ﺣﺮوف ﺑﺎدﺋﺔ ﻗﺒﻞ اﺳﻢ اﻷداة‬               ‫ﻣﻼﺣﻈﺔ:‬
 ‫ﺑﺤﻴﺚ ﻳﺴﺘﺪل اﻟﻤﺒﺮﻣﺞ ﻋﻠـﻰ ﻧـﻮع اﻻداة ﻋـﻦ ﻃﺮﻳـﻖ اﻷﺳـﻢ آــ ‪frm‬‬
 ‫ﻟﻨﺎﻓﺬة اﻟﻨﻤﻮذج، ‪ cmd‬ﻟﺰر اﻻواﻣﺮ، ‪ txt‬ﻟﺨﺎﻧﺔ اﻟﻨﺺ .... اﻟﺦ، وﺳـﺘﻼﺣﻆ‬
   ‫ـ‬           ‫ـ‬      ‫ـ‬
 ‫اﻧﻨ ـﻲ اﺗﺒﻌﻬ ـﺎ ﺑﺸ ـﻜﻞ ﺟﻠﻴ ـﻞ ﻓ ـﻲ اﻟﻜﺘ ـﺎب ﻟﺘﻤﺴ ـﻜﻲ ﺑﻌ ـﺎدات وﺗﻘﺎﻟﻴ ـﺪ‬
                               ‫ـ‬       ‫ـ ـ‬          ‫ـ‬     ‫ـ‬        ‫ـ‬
                                       ‫اﺣﺰاب ‪ Visual Basic‬اﻟﺒﺮﻣﺠﻴﺔ.‬

                          ‫وﺑﺬﻟﻚ ﻧﻜﻮن ﻗﺪ اﻧﺘﻬﻴﻨﺎ ﻣﻦ اﻟﺨﻄﻮة اﻟﺜﺎﻟﺜﺔ: ﺗﺼﻤﻴﻢ اﻟﻮاﺟﻬﺔ.‬

                                       ‫اﻟﺨﻄﻮة اﻟﺮاﺑﻌﺔ: آﺘﺎﺑﺔ اﻟﺘﻌﻠﻴﻤﺎت‬
‫ﺑﻌﺪ ﺗﺼﻤﻴﻢ اﻟﻮاﺟﻬﺔ واﻻﻗﺘﻨﺎع ﺑﻤﻈﻬﺮهﺎ اﻟﻔﺎﺗﻦ، ﺗﺒﺪأ ﺧﻄﻮة آﺘﺎﺑﺔ اﻟﺘﻌﻠﻴﻤﺎت او اﻻآـﻮاد‬
‫أي ﺧﻄﻮة اﻟﺒﺮﻣﺠﺔ اﻟﻔﻌﻠﻴﺔ. ﻗﻢ ﺑـﺎﻟﻨﻘﺮ اﻟﻤـﺰدوج ﻋﻠـﻰ زر اﻻواﻣـﺮ، ﺳـﺘﻼﺣﻆ ان ﻧﺎﻓـﺬة‬
                          ‫ﻣﺤﺮر اﻻآﻮاد ‪ Code Window‬ﻗﺪ اﻧﻴﺮت وﻇﻬﺮ ﺑﻬﺎ هﺬا اﻟﻜﻮد:‬

‫)(‪Private Sub cmdMultiply_Click‬‬

‫‪End Sub‬‬
                                                  ‫51‬


‫أي آﻮد ﺗﻜﺘﺒﻪ ﺑﻴﻦ اﻟﺴﻄﺮﻳﻦ اﻟﺴﺎﺑﻘﻴﻦ ﺳﻴﺘﻢ ﺗﻨﻔﻴـﺬﻩ اذا ﻣـﺎ ﻗـﺎم اﻟﻤﺴـﺘﺨﺪم ﺑـﺎﻟﻨﻘﺮ‬
‫ﻋﻠﻰ زر اﻻواﻣﺮ، ﻓﻬﻮ ﻣﻜﺎن اﻟﺤـﺪث ‪ Click‬اﻟﺘـﺎﺑﻊ ﻟـﻸداة ‪ .cmdMultiply‬وهـﺬﻩ ﻓﻠﺴـﻔﺔ‬
‫اﻟﺒﺮﻣﺠﺔ اﻟﻤﺴﻴﺮة ﺑﺎﻻﺣﺪاث ‪ ،Event Driven Programming‬ﻓـﺎﻻآﻮاد ﻻ ﻳـﺘﻢ ﺗﻨﻔﻴـﺬهﺎ‬
‫ﻣﻦ اول ﺳﻄﺮ اﻟﻰ اﺧﺮ ﺳﻄﺮ آﻤﺎ ﻓﻲ اﻟﺴﺎﺑﻖ. آﺤـﻞ اﻟﺴـﻄﺮ اﻟﺴـﺎﺑﻖ ﺑﻜﺘﺎﺑـﺔ اﻟﻜـﻮد‬
                                              ‫اﻟﺘﺎﻟﻲ اﻟﺨﺎص ﺑﺎﺟﺮاء ﻋﻤﻠﻴﺔ اﻟﻀﺮب:‬

‫)(‪Private Sub cmdMultiply_Click‬‬
      ‫)‪lblProduct.Caption = CDbl(txtFirst.Text) * CDbl(txtSecond.Text‬‬
‫‪End Sub‬‬

‫ان ﻟﻢ ﺗﻔﻬﻢ اﻟﻐﺮض ﻣﻦ اﻟﻜﻮد اﻟﺴـﺎﺑﻖ، ﻓﺎﻟﻔﺼـﻮل اﻟﻘﺎدﻣـﺔ ﺁﺗﻴـﺔ اﻟﻴـﻚ، وﺳـﺘﺠﺪ ﻓﻴﻬـﺎ‬
‫اﻟﺠﻮاب اﻟﺸﺎﻓﻲ، وﻟﻜﻦ اﻋﺮف اﻻن –ﺑﺸﻜﻞ ﻣﺆﻗـﺖ- ان اﻟﻜـﻮد اﻟﺴـﺎﺑﻖ ﻳﻘـﻮم ﺑﻌﻤﻠﻴـﺔ‬
‫ﺿﺮب اﻟﻘﻴﻢ اﻟﺘﻲ ﺳﻴﻜﺘﺒﻬﺎ اﻟﻤﺴﺘﺨﺪم ﻓﻲ ﺧﺎﻧﺎت اﻟـﻨﺺ وﺳﻴﻀـﻊ ﻧـﺎﺗﺞ اﻟﻀـﺮب ﻓـﻲ‬
                                                                   ‫أداة اﻟﻌﻨﻮان.‬

                                   ‫اﻟﺨﻄﻮة اﻟﺨﺎﻣﺴﺔ: اﻟﺘﺠﺮﺑﺔ واﻟﺘﻌﺪﻳﻞ‬
‫ﻗﻢ ﻓﻮرا ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ اﻟﻤﻔﺘﺎح ]5‪ [F‬ﻟﺘﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ. ﺳﺘﻈﻬﺮ ﻟﻚ ﻧﺎﻓﺬة اﻟﻨﻤـﻮذج اﻟﺘـﻲ‬
‫ﺻﻤﻤﺘﻬﺎ وآﺎﻓﺔ اﻻدوات ﻣﺤﻀﻮﻧﺔ ﺑﻬﺎ، اآﺘﺐ اﻻﻋﺪاد 2 و 5 ﻓﻲ ﺧﺎﻧـﺎت اﻟـﻨﺺ وﻣـﻦ ﺛـﻢ‬
             ‫اﻧﻘﺮ ﻋﻠﻰ اﻟﺰر "اﺿﺮب" آﻲ ﺗﺤﺼﻞ ﻋﻠﻰ اﻟﻨﺎﺗﺞ 01 ﻻﻣﻌﺎ ﻓﻲ أداة اﻟﻌﻨﻮان.‬
‫اذا آﻨﺖ ﻣﺴﺮورا ﺟﺪا ﻣﻦ ﻧﺠﺎح ﻋﻤﻠﻴﺔ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ، ﻓﺘﺬآﺮ ان ﻋﻨـﻮان هـﺬﻩ اﻟﺨﻄـﻮة‬
                           ‫ﺎ‬
‫"اﻟﺘﺠﺮﺑﺔ واﻟﺘﻌﺪﻳﻞ" وﻟـﻴﺲ "اﻟﺘﻨﻔﻴـﺬ"، ﻻﻧـﻚ ﺳﺘﻀـﻄﺮ ﻻﺣﻘـً ﻻﻋـﺎدة ﺗﻨﻘـﻴﺢ ﺑﺮﻧﺎﻣﺠـﻚ‬
‫ﺑﻌﺪﻣﺎ ﺗﻜﺘﺸﻒ هﺬﻩ اﻟﻤﺸﻜﻠﺔ اﻟﺒﺴـﻴﻄﺔ اذا ﻗـﺎم اﻟﻤﺴـﺘﺨﺪم ﺑﻜﺘﺎﺑـﺔ ﺣـﺮوف –وﻟـﻴﺲ‬
‫اﻋﺪاد- ﻓﻲ ﺧﺎﻧﺎت اﻟﻨﺺ ﺛﻢ ﻗـﺎم ﺑـﺎﻟﻨﻘﺮ ﻋﻠـﻰ اﻟـﺰر "اﺿـﺮب"، ﺳـﺘﻼﺣﻆ ﻇﻬـﻮر رﺳـﺎﻟﺔ‬
‫ﺧﻄﺄ، وﺳﻴﺘﻮﻗﻒ اﻟﺒﺮﻧـﺎﻣﺞ ﻋـﻦ اﻟﻌﻤـﻞ. ﻳﻌـﺮف هـﺬا اﻟﻨـﻮع ﻣـﻦ اﻷﺧﻄـﺎء ﺑﺎﺧﻄـﺎء وﻗـﺖ‬
‫اﻟﺘﻨﻔﻴـﺬ ‪ Run Time Errors‬وﺳـﺘﺨﺘﻔﻲ ﺑﻬﺠـﺔ اﻟﻔﺮﺣـﺔ ﺑﺎآﺘﻤـﺎل ﺑﺮﻧﺎﻣﺠـﻚ اﻻول، ﻻن‬
                    ‫‪ Visual Basic‬ﻻ ﻳﺠﺮي ﻋﻤﻠﻴﺔ اﻟﻀﺮب ﻋﻠﻰ اﻟﺤﺮوف، ﻓﻼ ﺗﺘﻮﻗﻊ ان:‬
                                         ‫ﺗﺮآﻲ * 5 = ﺗﺮآﻲ ﺗﺮآﻲ ﺗﺮآﻲ ﺗﺮآﻲ ﺗﺮآﻲ‬
  ‫ـ‬    ‫ـ ـ‬              ‫ـ‬     ‫ـ‬    ‫ـ‬
‫ﻟ ـﺬﻟﻚ، ﻋﻠﻴ ـﻚ ﺑﺎﻋ ـﺎدة ﻋﻤﻠﻴ ـﺔ ﺗﻌ ـﺪﻳﻞ اﻟﻜ ـﻮد ﻟﻴﺘﺤﻘ ـﻖ ﻣ ـﻦ اﻟﻘ ـﻴﻢ اﻟﻤﺪﺧﻠ ـﺔ ﻣ ـﻦ ﻗﺒ ـﻞ‬
                                             ‫ـ‬         ‫ـ‬    ‫ـ‬         ‫ـ‬      ‫ـ‬         ‫ـ‬
‫اﻟﻤﺴﺘﺨﺪم ﻗﺒﻞ اﺟﺮاء ﻋﻤﻠﻴﺔ اﻟﻀﺮب ﻋﻠﻴﻬﺎ، وﻳﺼـﺒﺢ اﻟﺸـﻜﻞ اﻟﻨﻬـﺎﺋﻲ ﻟﻠﻜـﻮد اﻟﻤﻌـﺪل‬
                                                 ‫هﻮ اﻟﻜﻮد اﻟﻤﻮﺟﻮد ﻓﻲ اﻟﺼﻔﺤﺔ اﻟﺘﺎﻟﻴﺔ:‬
                                              ‫61‬



‫)(‪Private Sub cmdMultiply_Click‬‬
   ‫اﻟﺘﺤﻘﻖ ﻣﻦ اﻟﻘﻴﻢ اﻟﻤﺪﺧﻠﺔ '‬
   ‫ﻗﺒﻞ اﺟﺮاء ﻋﻤﻠﻴﺔ اﻟﻀﺮب ﻋﻠﻴﻬﺎ '‬
   ‫‪If IsNumeric(txtFirst.Text) = True And IsNumeric(txtSecond.Text) = True Then‬‬
       ‫)‪lblProduct.Caption = CDbl(txtFirst.Text) * CDbl(txtSecond.Text‬‬
   ‫‪Else‬‬
       ‫"!اﻟﻘﻴﻢ اﻟﻤﺪﺧﻠﺔ ﻏﻴﺮ ﺻﺤﻴﺤﺔ" ‪MsgBox‬‬
   ‫‪End If‬‬
‫‪End Sub‬‬

‫اﻟﻬﺪف ﻣﻦ هﺬﻩ اﻟﺨﻄﻮة ﻟﻴﺲ ﺷﺮح اﻻآﻮاد او ﻃﺮﻳﻘـﺔ ﺗﻔـﺎدي اﻻﺧﻄـﺎء، واﻧﻤـﺎ ﺗﻮﺿـﻴﺢ‬
             ‫ﻗﻀﻴﺔ اﻟﺘﺠﺮﺑﺔ واﻟﺘﻌﺪﻳﻞ وﺑﻴﺎن اهﻤﻴﺘﻬﺎ ﻗﺒﻞ اﻻﻧﺘﻬﺎء ﻣﻦ ﺗﺼﻤﻴﻢ اﻟﺒﺮﻧﺎﻣﺞ.‬

                                           ‫اﻟﺨﻄﻮة اﻟﺴﺎدﺳﺔ: اﻟﺘﺮﺟﻤﺔ‬
‫اﺗﻤﻨﻰ ان ﺗﻜﻮن ﻓﺮﺣﺔ ﻧﺠـﺎح ﺑﺮﻧﺎﻣﺠـﻚ ﻗـﺪ ﻋـﺎدت ﻣـﻦ ﺟﺪﻳـﺪ، اﻟﺨﻄـﻮة اﻻﺧﻴـﺮة اﻟﺘـﻲ‬
‫ﺳﻨﻘﻮم ﺑﻬﺎ ﺗﻌﺮف ﺑﺎﻟﺘﺮﺟﻤﺔ ‪ ،Compiling‬واﻟﻤﻘﺼﻮد ﻣﻨﻬﺎ ﻋﻤﻠﻴﺔ ﺗﺤﻮﻳﻞ ﺑﺮﻧﺎﻣﺠـﻚ اﻟـﻰ‬
‫ﻣﻠـــﻒ ﺗﻨﻔﻴـــﺬي ‪ Executable‬ﺑﺎﻻﻣﺘـــﺪاد ‪ ،EXE‬ﻳـــﺘﻢ ذﻟـــﻚ ﺑﺎﺧﺘﻴـــﺎر اﻻﻣـــﺮ ‪Make‬‬
                                             ‫‪ MyFirstProgram.EXE‬ﻣﻦ ﻗﺎﺋﻤﺔ ‪.File‬‬

 ‫ﻓﻲ ﻣﻌﻈﻢ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ اﻻﺧﺮى، اﻟﺘﺮﺟﻤﺔ ‪ Compiling‬ﺗﻜـﻮن ﻋﻤﻠﻴـﺔ‬            ‫ﻣﻼﺣﻈﺔ:‬
 ‫ﻗﺒﻞ ﻋﻤﻠﻴﺔ اﻟـﺮﺑﻂ ‪ Linking‬اﻟﺘـﻲ ﺗﻨـﺘﺞ ﻣﻠﻔـﺎت ‪ .EXE‬اﻣـﺎ ﻣـﻊ ‪Visual‬‬
             ‫‪ ،Basic‬ﻓﺎﻟﺘﺮﺟﻤﺔ ‪ Compiling‬هﻲ ﻧﻔﺲ اﻟﺮﺑﻂ ‪.Linking‬‬

‫اﻟﻤﻴﺰة ﻓﻲ ﻋﻤﻠﻴﺔ اﻟﺘﺮﺟﻤﺔ هﻲ اﻣﻜﺎﻧﻴﺔ ﺗﻨﻔﻴﺬ ﺑﺮﻧﺎﻣﺠـﻚ ﻋﻠـﻰ ﺟﻤﻴـﻊ اﻻﺟﻬـﺰة اﻟﺘـﻲ‬
‫ﺗﺤﻤﻞ ﻧﻈﺎم اﻟﺘﺸﻐﻴﻞ ‪ Windows‬ﺑﺎﺧﺘﻼف اﺻﺪاراﺗﻪ واﻟﺘﻲ ﻻ ﺗﺤﺘﻮي ﻋﻠﻰ ﻧﺴﺨﺔ ﻣﻦ‬
‫‪ Visual Basic‬ﺷﺮﻳﻄﺔ وﺟﻮد ﺑﻌﺾ ﻣﻜﺘﺒـﺎت ‪ DLL‬اﻟﺘـﻲ ﺗـﺄﺗﻲ ﻣـﻊ ‪ ،Visual Basic‬ﻟﻌـﻞ‬
‫اﺑﺮزهﺎ ﻣﻜﺘﺒﺔ ‪ .MSVBVM60.DLL‬ﻟﺬﻟﻚ، ﻋﻠﻴﻚ ارﻓﺎق هﺬﻩ اﻟﻤﻜﺘﺒﺔ ﻣﻊ ﻣﻠـﻒ ﺑﺮﻧﺎﻣﺠـﻚ‬
           ‫اﻟﺮﺋﻴﺴﻲ ‪ EXE‬اﻟﻰ اﻻﺟﻬﺰة اﻻﺧﺮى واﻟﺘﻲ ﻻ ﺗﺤﺘﻮي ﻋﻠﻰ ‪.Visual Basic‬‬
                                                ‫71‬


                                       ‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬
                             ‫اﻟﻨﻤﺎذج واﻻدوات‬


‫اﻟﻨﻤﻮذج ‪ Form‬هﻮ ﻣﺼﻄﻠﺢ ﺧﺎص ﺑـ ‪ Visual Basic‬ﻣﺮادف ﻟﻠﻨﺎﻓﺬة ‪ ،Window‬واﻟﻨﻤﻮذج‬
‫هﻮ ﺑﺎﻟﻔﻌﻞ ﻧﺎﻓﺬة ﺗﻘﻮم ﺑﺘﺼﻤﻴﻤﻬﺎ وﺗﻈﻬـﺮ ﻓـﻲ وﻗـﺖ اﻟﺘﻨﻔﻴـﺬ آﺴـﺎﺋﺮ ﻧﻮاﻓـﺬ ﺗﻄﺒﻴﻘـﺎت‬
‫‪ .Windows‬اﻣﺎ اﻻدوات ‪ Controls‬ﻓﻬﻲ ﻧﻮاﻓﺬ اﻳﻀﺎ، وﻟﻜﻦ ﻣﻦ ﻧـﻮع ﺧـﺎص ﺗﻮﺿـﻊ داﺋﻤـﺎ‬
‫داﺧﻞ اﻟﻨﻤﺎذج وﺗﺤﺘﻀﻦ ﻓﻴﻪ. ﻣﻦ اﻟﻤﻬﻢ ان اﻟﻔﺖ اﻟﻨﻈﺮ اﻟﻰ وﺟﻮد ﻧـﻮﻋﻴﻦ ﻣـﻦ اﻻدوات‬
‫اﻟﺘﻲ ﻳﻤﻜﻦ اﺳﺘﺨﺪاﻣﻬﺎ ﻣﻊ ‪ ،Visual Basic‬اﻟﻨﻮع اﻻول هﻲ اﻻدوات اﻟﺪاﺧﻠﻴﺔ ‪Built-in‬‬
‫‪- Controls‬او اﻟﺠﻮهﺮﻳـﺔ ‪ -Intrinsic Controls‬وهـﻲ اﻟﻌﺸـﺮﻳﻦ أداة اﻟﻤﻮﺟـﻮدة ﻣﺒـﺪﺋﻴﺎ‬
‫ﻓﻲ ﻧﺎﻓﺬة ﺻﻨﺪوق اﻻدوات ﺷﻜﻞ 1-2. ﺟﻤﻴﻊ ﺑﺮاﻣﺠﻚ اﻟﻤﺼﻤﻤﺔ ﺗﺤـﺖ ‪Visual Basic‬‬
‫ﻣﻠﺰﻣـــﺔ ﺑﻬـــﺬﻩ اﻻدوات ﺣﺘـــﻰ ﻟـــﻮ ﻟـــﻢ ﺗﺴـــﺘﺨﺪﻣﻬﺎ، ﻓﻬـــﻲ ﻣﻀـــﻤﻨﺔ ﻓـــﻲ ﻣﻜﺘﺒـــﺔ‬
‫‪ MSVBVM60.DLL‬اﻟﺘﻲ ﻳﺸﺘﺮط وﺟﻮدهﺎ ﻟﺘﻨﻔﻴﺬ ﺑﺮاﻣﺠﻚ. اﻣﺎ اﻟﻨﻮع اﻟﺜﺎﻧﻲ ﻣﻦ اﻻدوات‬
‫ﻓﺘﻌﺮف ﺑﺎﻻﺳﻢ ‪ ActiveX Controls‬وهﻲ ادوات ﺧﺎرﺟﻴـﺔ ﻳﻜـﻮن اﻣﺘـﺪاد ﻣﻠﻔﺎﺗﻬـﺎ ‪.OCX‬‬
‫ﻻﺳﺘﺨﺪام هﺬا اﻟﻨﻮع ﻣﻦ اﻻدوات، ﻋﻠﻴﻚ اﺿـﺎﻓﺘﻬﺎ اﻟـﻰ ﻣﺸـﺮوﻋﻚ ﻋـﻦ ﻃﺮﻳـﻖ اﺧﺘﻴـﺎر‬
                                             ‫اﻻﻣﺮ ‪ Components‬ﻣﻦ ﻗﺎﺋﻤﺔ ‪.Project‬‬
‫اﻟﻨﻤﺎذج واﻻدوات ﺗﺘﺸﺎرك ﻓﻲ ﺻﻔﺔ ﻣﺸﺘﺮآﺔ واﺣﺪة وهﻲ اﻧﻬﺎ آﺎﺋﻨﺎت ‪ .Objects‬وﺑﻤـﺎ‬
‫اﻧﻬﺎ آﺎﺋﻨﺎت، ﻓﻬﻲ ﺗﺘﻜﻮن ﻣﻦ ﺛﻼث ﻋﻨﺎﺻﺮ -ﺗﺴﻤﻰ اﻻﻋﻀﺎء ‪ -Members‬ﺗﻤﻴﺰ اﻟﻜﺎﺋﻨـﺎت‬
  ‫ـ‬
‫ﻋـﻦ ﻏﻴﺮهـﺎ هـﻲ: اﻟﺨﺼـﺎﺋﺺ ‪ ،Properties‬اﻟﻄـﺮق ‪ Methods‬واﻻﺣـﺪاث ‪ .Events‬آـﻞ‬
‫آﺎﺋﻦ ﻣﻦ آﺎﺋﻨﺎت ‪ Visual Basic‬ﻳﺤﺘﻮي ﻋﻠـﻰ اﻋﻀـﺎء ﺧﺎﺻـﺔ ﺑـﻪ، ﻓـﺎﻟﻨﻤﻮذج ﻟـﻪ اﻋﻀـﺎء‬
                            ‫ـ‬                                ‫ـ‬                    ‫ـ‬
‫ﻣﺴ ـﺘﻘﻠﺔ وأداة اﻟــﻨﺺ ﻟﻬ ـﺎ اﻋﻀــﺎء ﻣﺴــﺘﻘﻠﺔ، اﻻ ان اﻟﻨﻤ ـﺎذج واﻻدوات ﺗﺤﺘﻮﻳــﺎن ﻋﻠــﻰ‬
‫ﻋﺸﺮات اﻻﻋﻀﺎء اﻟﻤﺸﺘﺮآﺔ ﺑﻴﻨﻬﺎ. ﻟﺬﻟﻚ، وﺟﺪت ﻣﻦ اﻻﻓﻀﻞ ان اﺑﺪأ ﺑﻌﺮض اﻟﺨﺼﺎﺋﺺ،‬
‫اﻟﻄﺮق واﻻﺣﺪاث اﻟﻤﺸﺘﺮآﺔ ﺑﻴﻦ اﻟﻨﻤﺎذج واﻻدوات، وﻣﻦ ﺛﻢ ذآﺮ اﻋﻀﺎء آﻞ آﺎﺋﻦ ﻋﻠﻰ‬
                                                                                 ‫ﺣﺪﻩ.‬


                                                          ‫اﻟﺨﺼﺎﺋﺺ اﻟﻤﺸﺘﺮآﺔ‬
‫اﻟﺨﺎﺻﻴﺔ هﻲ ﻗﻴﻤﺔ ﺗﺆﺛﺮ اﻣﺎ ﻓﻲ اﻟﺸﻜﻞ اﻟﺨﺎرﺟﻲ ﻟﻸداة آــ ‪ ،Caption‬او ﻓـﻲ ﺳـﻠﻮك‬
‫ﻋﻤﻞ اﻷداة آـ ‪ .Enabled‬ﻧﺎﻓﺬة اﻟﺨﺼﺎﺋﺺ هﻲ اﻟﻤﻜﺎن اﻟﺬي ﻳﻤﻜﻨـﻚ ﻣـﻦ ﺗﻐﻴﻴـﺮ ﻗﻴﻤـﺔ‬
                                                ‫81‬


‫اﻟﺨﺎﺻﻴﺔ وﻗﺖ اﻟﺘﺼﻤﻴﻢ، اﻣـﺎ وﻗـﺖ اﻟﺘﻨﻔﻴـﺬ ﻓﻌﻠﻴـﻚ آﺘﺎﺑـﺔ اﻟﻜـﻮد واﻟـﺬي ﺗﻜـﻮن ﺻـﻴﻐﺘﻪ‬
                                      ‫ﻣﺒﺘﺪﺋﺔ ﺑﺎﺳﻢ اﻷداة ﻓﻨﻘﻄﺔ ﺛﻢ اﺳﻢ اﻟﺨﺎﺻﻴﺔ:‬
‫”ﺗﺮآﻲ اﻟﻌﺴﻴﺮي“ = ‪Text1.Text‬‬
‫0 = ‪PictureBox1.BackColor‬‬
‫‪Label1.Caption = Text1.Text‬‬

‫او اﺳﺘﺨﺪام اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ With‬اذا آﻨﺖ ﺗﺮﻏﺐ ﺗﻌﺪﻳﻞ ﻣﺠﻤﻮﻋـﺔ ﺧﺼـﺎﺋﺺ ﻟﻜـﺎﺋﻦ‬
                                                            ‫او اداة ﻣﻌﻴﻨﺔ:‬

‫1‪With Text‬‬
  ‫"ﺗﺮآﻲ اﻟﻌﺴﻴﺮي" = ‪.Text‬‬
  ‫‪.Font.Bold = True‬‬
  ‫‪.BackColor = vbBlack‬‬
  ‫‪.ForeColor = vbWhite‬‬
‫‪End With‬‬

‫ﺗﺘﻤﻴﺰ ﺑﻌﺾ اﻷدوات ﺑﻮﺟﻮد ﺧﺎﺻﻴﺔ اﻓﺘﺮاﺿـﻴﺔ ﻟﻬـﺎ ﺗﻌـﺮف ﺑــ ‪ ،Default Property‬ﺗﻐﻨﻴـﻚ‬
 ‫ﺎ‬
‫هﺬﻩ اﻟﺨﺎﺻـﻴﺔ ﻋـﻦ آﺘﺎﺑـﺔ اﺳـﻢ اﻟﺨﺎﺻـﻴﺔ ﺑﻌـﺪ اﻷداة اذا اردت ﺗﻐﻴﻴـﺮ ﻗﻴﻤﺘﻬـﺎ ﺑﺮﻣﺠﻴـً.‬
        ‫ـ‬                    ‫ـ‬     ‫ـ‬            ‫ـ‬       ‫ـ‬   ‫ـ‬                ‫ـ‬
‫ﻣﻌﻈ ـﻢ اﻻدوات اﻟﺪاﺧﻠﻴ ـﺔ ﺗﻜ ـﻮن ﺧﺎﺻ ـﻴﺘﻬﺎ اﻻﻓﺘﺮاﺿ ـﻴﺔ ه ـﻲ ‪ Caption‬واﻟﺨﺎﺻ ـﻴﺔ ‪Text‬‬
                                                                        ‫ﻷداة اﻟﻨﺺ:‬

‫”اﻟﺨﺎﺻﻴﺔ اﻻﻓﺘﺮاﺿﻴﺔ“ = ‪Label1.Caption‬‬
‫”اﻟﺨﺎﺻﻴﺔ اﻻﻓﺘﺮاﺿﻴﺔ“ = 1‪Label‬‬
‫”‪Text1 = “Text1.Text‬‬

‫ﺑﺎﻟﻨﺴــﺒﺔ ﻟﻨﺎﻓــﺬة اﻟﻨﻤــﻮذج، ﻳﻤﻜﻨــﻚ اﻟﻮﺻــﻮل اﻟــﻰ ﺧﺼﺎﺋﺼــﻬﺎ دون اﻻﻟﺘــﺰام ﺑﺎﻟﺼــﻴﻐﺔ‬
                 ‫اﻟﺴﺎﺑﻘﺔ ﻓﺘﺴﺘﻄﻴﻊ اﺳﺘﺨﺪام اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ Me‬او ﺣﺘﻰ ﺗﺠﺎهﻠﻬﺎ:‬

‫ﺟﻤﻴﻊ اﻻآﻮاد اﻟﺘﺎﻟﻴﺔ ﻣﺘﺸﺎﺑﻬﻪ ‘‬
‫”اﻟﻨﺎﻓﺬة اﻟﺮﺋﻴﺴﺔ“ = ‪Form1.Caption‬‬
‫”اﻟﻨﺎﻓﺬة اﻟﺮﺋﻴﺴﺔ“ = ‪Me.Caption‬‬
‫”اﻟﻨﺎﻓﺬة اﻟﺮﺋﻴﺴﺔ“ = ‪Caption‬‬

‫ﻣﻦ اﻟﻀﺮوري ان اﻧﺒﻪ هﻨﺎ إﻟﻰ اﻧﻪ ﻟﻴﺴﺖ آﻞ اﻟﺨﺼﺎﺋﺺ ﻗﺎﺑﻠﺔ ﻟﻠﺘﻌﺪﻳﻞ وﻗـﺖ اﻟﺘﺼـﻤﻴﻢ‬
‫واﻟﺘﻨﻔﻴﺬ، ﻓﺒﻌﺾ اﻟﺨﺼﺎﺋﺺ آـ ‪ BorderStyle‬اﻟﺘﺎﺑﻌﺔ ﻟﻨﺎﻓـﺬة اﻟﻨﻤـﻮذج ﻻﻳﻤﻜﻨـﻚ ﺗﻌـﺪﻳﻠﻬﺎ‬
                                                 ‫91‬


‫وﻗﺖ اﻟﺘﻨﻔﻴﺬ، وﻋﻠـﻰ اﻟﻌﻜـﺲ اﻟﺨﺎﺻـﻴﺔ ‪- CurrentX‬اﻟﺘﺎﺑﻌـﺔ ﻟـﻨﻔﺲ اﻟﻜـﺎﺋﻦ- ﻻﻳﻤﻜﻨـﻚ‬
‫ﺗﻌﺪﻳﻠﻬﺎ اﻻ وﻗـﺖ اﻟﺘﻨﻔﻴـﺬ. اﻟﻤﺰﻳـﺪ اﻳﻀـﺎ، هﻨﺎﻟـﻚ ﺑﻌـﺾ اﻟﺨﺼـﺎﺋﺺ ﻏﻴـﺮ ﻗﺎﺑﻠـﺔ ﻟﻠﺘﻌـﺪﻳﻞ‬
‫ﻣﻄﻠﻘﺎ –ﻻ ﻓﻲ وﻗﺖ اﻟﺘﻨﻔﻴﺬ وﻻ اﻟﺘﺼـﻤﻴﻢ- آﺎﻟﺨﺎﺻـﻴﺔ ‪ ،hWnd‬ﻓﻬـﻲ ﺧﺼـﺎﺋﺺ ﺗﻘﺮأهـﺎ‬
‫ﻓﻘﻂ وﺗﺴﺘﻔﻴﺪ ﻣﻦ ﻗﻴﻤﻬﺎ وهﻲ ﺗﻌﺮف ﺑﺨﺼﺎﺋﺺ اﻟﻘـﺮاءة ﻓﻘـﻂ ‪Read Only Properties‬‬
‫ﻓﻲ وﻗﺖ اﻟﺘﻨﻔﻴﺬ او اﻟﺘﺼﻤﻴﻢ او آﻼهﻤـﺎ. وﻋﻠـﻰ اﻟﻌﻜـﺲ، ﻳﻮﺟـﺪ ﻧـﻮع ﻣـﻦ اﻟﺨﺼـﺎﺋﺺ‬
‫ﺗﻌﺮف ﺑﺎﻟﻜﺘﺎﺑﺔ ﻓﻘﻂ ‪ Write Only Properties‬وﻻ ﺗﺴﺘﻄﻴﻊ ﻗﺮاءﺗﻬﺎ ﻓـﻲ وﻗـﺖ اﻟﺘﺼـﻤﻴﻢ‬
                                                              ‫او اﻟﺘﻨﻔﻴﺬ او آﻼهﻤﺎ.‬
‫واﻵن دﻋﻨﺎ ﻧﺘﻌـﺮف اآﺜـﺮ ﻋﻠـﻰ اﻟﺨﺼـﺎﺋﺺ اﻟﻤﺸـﺘﺮآﺔ ﻟـﻼدوات، واﻟﺒﺪاﻳـﺔ ﺳـﺘﻜﻮن ﻣـﻊ‬
                                                            ‫ﺧﺎﺻﻴﺔ اﻻﺳﻢ ‪.Name‬‬

                                                        ‫ﺧﺎﺻﻴﺔ اﻻﺳﻢ ‪Name‬‬
‫ﺗﻌﺪﻳﻞ هﺬﻩ اﻟﺨﺎﺻﻴﺔ ﻣﻤﻜـﻦ ﻓـﻲ وﻗـﺖ اﻟﺘﺼـﻤﻴﻢ ﻓﻘـﻂ، وهـﻲ اﻟﺨﺎﺻـﻴﺔ اﻟﺘـﻲ ﺗﻤﺜـﻞ‬
‫اﻻﺳﻢ اﻟﺒﺮﻣﺠﻲ ﻟﻸداة. ﻓﺎﻻﺳﻢ اﻟـﺬي ﺗﻜﺘﺒـﻪ ﻓـﻲ هـﺬﻩ اﻟﺨﺎﺻـﻴﺔ هـﻮ اﻻﺳـﻢ اﻟـﺬي‬
‫ﺗﺴﺘﺨﺪﻣﻪ ﺑﺮﻣﺠﻴﺎ ﻟﻠﻮﺻﻮل اﻟﻰ ﺧﺼﺎﺋﺼﻬﺎ، ﻃﺮﻗﻬﺎ وﺣﺘﻰ اﺣﺪاﺛﻬﺎ. وآﻨﺼﻴﺤﺔ ﻻ ﺗﺤـﺎول‬
‫اﺑﺪا ﺗﻐﻴﻴﺮ اﺳﻢ اﻷداة ﺑﻌﺪ آﺘﺎﺑﺔ اﻟﻜﺜﺒﺮ ﻣـﻦ اﻻآـﻮاد، ﻓـﺎن ذﻟـﻚ ﺳﻴﻀـﻄﺮك اﻟـﻰ ﺗﻐﻴﻴـﺮ‬
‫ﺟﻤﻴﻊ اﻻآﻮاد ﻟﻼﺳﻢ اﻟﺴﺎﺑﻖ ﻟﻸداة. ﻧﺼﻴﺤﺔ اﺧﺮى، ﻻ ﺗﺤﺎول اﻻﻋﺘﻤﺎد ﻋﻠﻰ اﻻﺳـﻤﺎء‬
‫اﻻﻓﺘﺮاﺿـﻴﺔ اﻟﺘـﻲ ﻳﻮﻓﺮهـﺎ ‪ Visual Basic‬ﻋﻨـﺪ ﺑﺪاﻳـﺔ رﺳـﻢ اﻷداة آــ 1‪،Form2 ،Form‬‬
     ‫ـ‬   ‫ـ‬        ‫ـ‬         ‫ـ‬
‫1‪ .... Label‬اﻟـﺦ، ﻓﻜﺜـﺮة ه ـﺬﻩ اﻻﺳـﻤﺎء ﺗﺴ ـﺒﺐ ﻟـﻚ ﺗﺸـﻮﻳﺶ ﻋﻠ ـﻰ ذاآﺮﺗـﻚ. آ ـﺬﻟﻚ‬
                                    ‫ـ‬     ‫ـ‬       ‫ـ‬       ‫ـ‬   ‫ـ‬     ‫ـ‬
                        ‫ﻻﺗﺴﺘﻄﻴﻊ اﺧﺘﻴﺎر اﺳﻢ ﻟﻸداة ﻣﺎدام ﻻ ﻳﺤﻘﻖ اﻟﺸﺮوط اﻟﺘﺎﻟﻴﺔ:‬
                                                                  ‫- ﻻ ﻳﺒﺪأ ﺑﺮﻗﻢ.‬
                                                            ‫- ﻻ ﻳﺰﻳﺪ ﻋﻦ 04 ﺣﺮف.‬
                            ‫- ﻻ ﻳﺤﺘﻮي ﻋﻠﻰ ﻣﺴﺎﻓﺔ او ﻋﻼﻣﺎت آـ &، ؟، " .... اﻟﺦ.‬
‫- ﻻ ﻳﻜﻮن ﻣﺤﺠﻮز ﻻﺳﻢ أداة اﺧـﺮى ﻓـﻲ ﻧﻔـﺲ اﻟﻨﻤـﻮذج او اﺳـﻢ ﻧﻤـﻮذج اﺧـﺮ ﻓـﻲ‬
             ‫ﻧﻔﺲ اﻟﻤﺸﺮوع –ﺑﺎﺳﺘﺜﻨﺎء ﻣﺼﻔﻮﻓﺔ اﻻدوات آﻤﺎ ﺳﻴﺄﺗﻲ ﺑﻴﺎﻧﻪ ﻻﺣﻘﺎ.‬

                                                   ‫ﺧﺼﺎﺋﺺ اﻟﻤﻮﻗﻊ واﻟﺤﺠﻢ‬
‫ﺧﺼﺎﺋﺺ اﻟﻤﻮﻗﻊ واﻟﺤﺠﻢ ﻣﻮﺟﻮدة ﻓﻲ ﺟﻤﻴﻊ اﻻدوات اﻟﻘﺎﺑﻠﺔ ﻟﻠﻈﻬﻮر –أي ﺗﺤﺘﻮي ﻋﻠﻰ‬
‫اﻟﺨﺎﺻﻴﺔ ‪ ،Visible‬اﻣﺎ اﻻدوات اﻻﺧﺮى آـﺄداة اﻟﻤﺆﻗـﺖ ‪ Timer‬ﻓﻤـﻦ اﻟﺒـﺪﻳﻬﻲ ان ﺗﻜـﻮن‬
       ‫هﺬﻩ اﻟﺨﺼﺎﺋﺺ ﻏﻴﺮ ﻣﻮﺟﻮدة ﻃﺎﻟﻤﺎ ان اﻷداة ﻏﻴﺮ ﻗﺎﺑﻠﺔ ﻟﻠﻈﻬﻮر اﺑﺪا وﻗﺖ اﻟﺘﻨﻔﻴﺬ.‬
‫ﺧﺼﺎﺋﺺ اﻟﻤﻮﻗﻊ ‪ Left‬و ‪ Top‬ﺗﺤﺪدان ﻣﻮﻗـﻊ اﻟﺰاوﻳـﺔ اﻟﻌﻠﻮﻳـﺔ اﻟﻴﺴـﺮى ﻟـﻸداة ﺑﺎﻟﻨﺴـﺒﺔ‬
‫اﻟﻰ اﻷداة اﻟﺤﺎﺿﻨﺔ ﻟﻬﺎ او ﻣﻮﻗﻊ اﻟﺰاوﻳﺔ اﻟﻌﻠﻮﻳﺔ اﻟﻴﺴﺮى ﻟﻨﺎﻓﺬة اﻟﻨﻤﻮذج ﺑﺎﻟﻨﺴﺒﺔ اﻟـﻰ‬
  ‫ـ‬           ‫ـ‬      ‫ـ‬         ‫ـ‬
‫اﻟﺸﺎﺷـ ـﺔ. اﻟﻮﺣـ ـﺪة اﻟﻤﺴـ ـﺘﺨﺪﻣﺔ هـ ـﻲ ﻧﻔـ ـﺲ اﻟﻮﺣـ ـﺪة اﻟﻤﺤـ ـﺪدة ﻓـ ـﻲ اﻟﺨﺎﺻـ ـﻴﺔ‬
                                         ‫ـ‬        ‫ـ‬          ‫ـ‬          ‫ـ‬         ‫ـ‬
‫‪ ScaleMode‬اﻟﺘﺎﺑﻌــﺔ ﻟــﻸداة اﻟﺤﺎﺿــﻨﺔ. اﻣــﺎ ﻧﺎﻓــﺬة اﻟﻨﻤــﻮذج، ﻓــﺪاﺋﻤﺎ ﺗﻜــﻮن اﻟﻮﺣــﺪة‬
                                                ‫02‬


‫اﻟﻤﺴﺘﺨﺪﻣﺔ ﻟﺘﺤﺪﻳﺪ ﻣﻮﻗﻌﻬﺎ هﻲ اﻟـ ‪ Twip‬آﻤﺎ ﺳﻨﻌﺮف ﻻﺣﻘﺎ. اذا آﻨﺖ ﺗﺮﻳـﺪ ﺗﻮﺳـﻴﻂ‬
‫اﻷداة وﻗﺖ اﻟﺘﺼﻤﻴﻢ ﻓﻲ ﻧﺎﻓﺬة اﻟﻨﻤﻮذج، ﺣـﺪد اﻷداة ﺛـﻢ اﺧﺘـﺮ اﺣـﺪ اﻻواﻣـﺮ اﻟﻤﻮﺟـﻮدة‬
‫ﻓﻲ اﻟﻘﺎﺋﻤﺔ اﻟﻔﺮﻋﻴﺔ ‪ Center in Form‬ﻣﻦ ﻗﺎﺋﻤﺔ ‪ ،Format‬اﻣﺎ ﻓﻲ وﻗﺖ اﻟﺘﻨﻔﻴﺬ ﻓﻬـﺬا‬
                                                              ‫اﻟﻜﻮد ﻳﻔﻲ ﺑﺎﻟﻐﺮض:‬

‫2 / )‪Command1.Left = (Me.ScaleWidth - Command1.Width‬‬
‫2 / )‪Command1.Top = (Me.ScaleHeight - Command1.Height‬‬

‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﺨﺼﺎﺋﺺ اﻟﺤﺠـﻢ ‪ Height‬و ‪ Width‬ﻓﻬـﻲ ﺗﻤﺜـﻞ ﻋـﺮض وﻃـﻮل اﻷداة ﺑـﻨﻔﺲ‬
‫اﻟﻮﺣﺪة اﻟﻤﺴﺘﺨﺪﻣﺔ ﻟﺨﺼﺎﺋﺺ اﻟﻤﻮﻗﻊ. ﻓـﻲ ﺣـﺎﻻت ﻣﻌﻴﻨـﺔ ﻟـﻦ ﺗﺴـﺘﻄﻴﻊ ﺗﻐﻴﻴـﺮ ﻗﻴﻤـﺔ‬
‫اﻟﺨﺎﺻــﻴﺔ ‪ Height‬ﻟــﺒﻌﺾ اﻻدوات آــﺄداة اﻟـــ ‪– ComboBox‬اذا آﺎﻧــﺖ ﺧﺎﺻــﻴﺘﻬﺎ ‪Style‬‬
‫ﻧﺴﺎوي 0، ﻓﻘﻴﻤـﺔ اﻟﺨﺎﺻـﻴﺔ ‪ Height‬هﻨـﺎ ﺳـﺘﻜﻮن ﻣﻌﺘﻤـﺪة ﻋﻠـﻰ ﻧـﻮع وﺣﺠـﻢ اﻟﺨـﻂ‬
‫اﻟﻤﺴــﺘﺨﺪم ﻓــﻲ اﻟﺨﺎﺻــﻴﺔ ‪ Font‬اﻟﺘﺎﺑﻌــﺔ ﻟﻬــﺎ. وﺑﻌــﺾ اﻻدوات –آــﺄداة ‪ -ListBox‬ﻓــﺈن‬
‫اﻟﺘﺤﻜﻢ ﻓﻲ ﺧﺎﺻﻴﺘﻬﺎ ‪ Height‬ﻟﻴﺲ دﻗﻴـﻖ ﺗﻤﺎﻣـﺎ، ﻓﻘﻴﻤـﺔ هـﺬﻩ اﻟﺨﺎﺻـﻴﺔ ﺗﻤﺜـﻞ ﻋـﺪد‬
‫اﻟﺴﻄﻮر ‪ x‬ارﺗﻔﺎع آﻞ ﺳـﻄﺮ، ﻓـﻼ ﺗﺘﻮﻗـﻊ ﻇﻬـﻮر ﺟـﺰء ﻣـﻦ ﺳـﻄﺮ ﻻن ﺳـﻄﻮر اﻟﻨﺼـﻮص‬
                                      ‫اﻟﻤﻮﺟﻮدة ﻓﻴﻬﺎ اﻣﺎ أن ﺗﻌﺮض آﺎﻣﻠﺔ او ﻻ ﺗﻌﺮض.‬

                                                          ‫ﺧﺼﺎﺋﺺ اﻻﺣﺘﻀﺎن‬
  ‫ـ‬      ‫ـ‬                ‫ـ‬         ‫ـ‬                        ‫ـ‬
‫ﺧﺼــﺎﺋﺺ اﻻﺣﺘﻀــﺎن ‪ Parent‬و ‪ Container‬ﺗﻤــﺜﻼن ﻣﺮﺟــﻊ ‪ Reference‬اﻟــﻰ ﻧﺎﻓــﺬة‬‫ـ‬
‫اﻟﻨﻤﻮذج اﻟﺤﺎﺿﻨﺔ ﻟـﻸداة ﻓـﻲ اﻟﺨﺎﺻـﻴﺔ ‪ Parent‬او اﻷداة اﻟﺤﺎﺿـﻨﺔ ﻟـﻸداة ‪.Container‬‬
‫اﻟﺨﺎﺻﻴﺔ ‪ Parent‬هﻲ ﻟﻠﻘﺮاءة ﻓﻘﻂ –أي ﻻ ﻳﻤﻜﻨـﻚ ﺗﻌـﺪﻳﻠﻬﺎ، اﻣـﺎ اﻟﺨﺎﺻـﻴﺔ ‪Container‬‬
                   ‫ﻓﻬﻲ ﻗﺎﺑﻠﺔ ﻟﻠﺘﻌﺪﻳﻞ ﻓﻲ أي وﻗﺖ ﺗﺮﻳﺪ ﺗﻐﻴﻴﺮ اﻷداة اﻟﺤﺎﺿﻨﺔ ﻟﻸداة:‬

‫ادﺧﺎل زر اﻻواﻣﺮ داﺧﻞ ‪‘ PictureBox‬‬
‫1‪Set Command1.Container = Picture‬‬

 ‫ﻻﺑــﺪ ﻣــﻦ اﺳــﺘﺨﺪام اﻟﻤﻌﺎﻣــﻞ ‪ Set‬ﻓــﻲ اﻟﻜــﻮد اﻟﺴــﺎﺑﻖ، ﻻﻧــﻚ ﺗﻘــﻮم‬   ‫ﻣﻼﺣﻈﺔ:‬
 ‫ﺑﺎﺳﻨﺎد ﻗﻴﻢ ﻟﻜﺎﺋﻨﺎت وﻟﻴﺲ ﻗﻴﻢ ﻋﺎدﻳﺔ، اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ ﺳﻴﻮﺿـﺢ ﻟـﻚ‬
                          ‫اﺳﺒﺎب اﺳﺘﺨﺪام اﻟﻤﻌﺎﻣﻞ ‪ Set‬ﺑﻤﺸﻴﺌﺔ اﷲ.‬

‫ﻣﻦ اﻟﻤﺮوﻧﺔ اﻟﺘﻲ ﺗﻮﻓﺮهﺎ ﻟﻚ هﺎﺗـﺎن اﻟﺨﺎﺻـﻴﺘﺎن هـﻲ اﻣﻜﺎﻧﻴـﺔ اﻟﻮﺻـﻮل اﻟـﻰ اﻋﻀـﺎء –‬
‫ﺧﺼﺎﺋﺺ وﻃﺮق- اﻷداة او ﻧﺎﻓﺬة اﻟﻨﻤﻮذج اﻟﺤﺎﺿﻨﺔ ﻟـﻸداة، ﻓـﺎﻟﻜﻮد اﻟﺘـﺎﻟﻲ ﻳﻘـﻮم ﺑﺘﻐﻴﻴـﺮ‬
                                     ‫اﻟﺨﺎﺻﻴﺔ ‪ Caption‬ﻟﻨﺎﻓﺬة اﻟﻨﻤﻮذج اﻟﺤﺎﺿﻨﺔ ﻟﻸداة:‬
                                             ‫12‬


‫"ﺗﻐﻴﺮ ﻋﻨﻮان اﻟﻨﺎﻓﺬة" = ‪Command1.Parent.Caption‬‬

‫اذا آﺎﻧﺖ اﻷداة ﻣﻮﺟﻮدة ﻋﻠﻰ ﻧﺎﻓﺬة اﻟﻨﻤﻮذج وﻟﻢ ﺗﺤﺘﻀﻨﻬﺎ أداة اﺧﺮى، ﻓﺎن اﻟﺨﺎﺻـﻴﺘﺎن‬
                        ‫‪ Parent‬و ‪ Container‬ﺗﻤﺜﻼن ﻧﻔﺲ اﻟﻤﺮﺟﻊ ﻟﻨﺎﻓﺬة اﻟﻨﻤﻮذج.‬

                                                       ‫ﺧﺎﺻﻴﺔ اﻟﺨﻂ ‪Font‬‬
‫ﺟﻤﻴﻊ اﻻدوات اﻟﺘﻲ ﺗﻌﺮض ﻧﺼﻮص ﻋﻠﻰ ﺟﺒﻬﺘﻬﺎ، ﺗﺤﺘﻮي ﻋﻠﻰ هـﺬﻩ اﻟﺨﺎﺻـﻴﺔ واﻟﺘـﻲ‬
‫ﺗﺤﺪد ﻓﻴﻬﺎ ﻧﻮع وﺣﺠﻢ اﻟﺨﻂ اﻟﻤﻌﺮوض ﻋﻠﻰ ﺟﺒﻬﺔ اﻷداة. اﻟﻮﻗﺖ اﻟﻤﻔﻀﻞ ﻟﺘﺤﺪﻳﺪ هﺬﻩ‬
‫اﻟﻘﻴﻤﺔ هﻮ وﻗﺖ اﻟﺘﺼﻤﻴﻢ وذﻟﻚ ﺑﺴﺒﺐ وﺟﻮد ﺻﻨﺪوق اﻟﺤـﻮار اﻟﻤـﺄﻟﻮف ‪ .Font‬اﻣـﺎ ﻓـﻲ‬
                                      ‫وﻗﺖ اﻟﺘﻨﻔﻴﺬ، ﻓﻌﻠﻴﻚ اﺳﺘﺨﺪام اﻟﻜﺎﺋﻦ ‪:Font‬‬

‫1‪With Label‬‬
       ‫”‪.Font.Name = “Tahoma‬‬
       ‫‪.Font.Bold = True‬‬
       ‫02 = ‪.Font.Size‬‬
‫‪End With‬‬

‫ﻣﻦ اﻟﻤﺮوﻧﺔ اﻟﺘﻲ ﻳﻮﻓﺮهﺎ ﻟﻚ اﻟﻜﺎﺋﻦ ‪ Font‬هﻲ ﻓﻜﺮة ﻧﺴﺦ ﺟﻤﻴﻊ ﺧﺼـﺎﺋﺺ اﻟﺨـﻂ ﻣـﻦ‬
                                                         ‫أداة اﻟﻰ اﺧﺮى:‬

‫‪Set Label1.Font = Label2.Font‬‬

‫ﻣﻦ اﻟﻤﻬﻢ ان ﺗﻌﻠﻢ اﻧـﻪ ﻓـﻲ اﻟﻜـﻮد اﻟﺴـﺎﺑﻖ ﻗﻤﻨـﺎ ﺑﻨﺴـﺦ اﻟﻜـﺎﺋﻦ ‪ Font‬اﻟﺘـﺎﺑﻊ ﻟـﻸداة‬
‫2‪ Label‬ﻣﻜﺎن اﻟﻜﺎﺋﻦ ‪ Font‬اﻟﺘﺎﺑﻊ ﻟﻸداة 1‪ Label‬ﻓﺎﻟﻜﺎﺋﻦ ‪ Font‬اﺻﺒﺢ آﺎﺋﻦ واﺣﺪ ﺗـﺮﺗﺒﻂ‬
‫ﺑﻪ اﻻداﺗـﻴﻦ، واﻟـﺪﻟﻴﻞ اﻧـﻪ ﻟـﻮ ﻗﻤـﺖ ﺑﺘﻌـﺪﻳﻞ اﺣـﺪ ﺧﺼـﺎﺋﺺ اﻟﺨـﻂ ﻟـﻸداة 2‪ Label‬ﻓـﺎن‬
                                     ‫ﺧﺎﺻﻴﺔ اﻟﺨﻂ اﻟﺘﺎﺑﻌﺔ ﻟﻸداة 1‪ Label‬ﺳﺘﺘﺄﺛﺮ اﻳﻀﺎ:‬

‫ﺳﺘﺘﺄﺛﺮ اﻳﻀﺎ اﻷداة 1‪‘ Label‬‬
‫02 = ‪Label2.Font.Size‬‬

        ‫اﻟﺴﺒﺐ ﻓﻲ اﻟﺘﺼﺮف اﻟﺴﺎﺑﻖ ﺧﺎص ﺑﻄﺒﻴﻌﺔ اﻟﻜﺎﺋﻦ ‪ Font‬اﻟﻐﺮﻳﺒﺔ ﺑﻌﺾ اﻟﺸﺊ.‬
                                                ‫22‬


 ‫اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ ﻳﺤﺘﻮي ﻋﻠﻰ اﻟﻌﺪﻳﺪ ﻣﻦ اﻻﻣﺜﻠﺔ اﻟﻌﻤﻠﻴﺔ، وﻳﻌﺮض‬                   ‫ﻣﻼﺣﻈﺔ:‬
 ‫ﻟﺘﻘﻨﻴﺎت ﻣﺘﻘﺪﻣﺔ ﻓﻲ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻜﺎﺋﻨﺎت ﺑﻤﺎ ﻓﻲ ذﻟﻚ ﻋﻤﻠﻴﺔ ﻧﺴﺦ‬
                                                   ‫اﻟﻜﺎﺋﻨﺎت.‬

‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﺨﺎﺻﻴﺔ ‪ Font.Name‬ﻓﻬﻲ ﺗﻤﺜﻞ اﺳﻢ اﻟﺨﻂ اﻟﻤﺮاد اﺳﺘﺨﺪاﻣﻪ، وﻓـﻲ ﺣـﺎل‬
‫اﺳــﺘﺨﺪاﻣﻚ ﻟﺨــﻂ ﻏﻴــﺮ ﻣﻮﺟــﻮد ﻓــﻲ ﻧﻈــﺎم اﻟﺘﺸــﻐﻴﻞ ﻓــﺎن ‪ Visual Basic‬ﻳﻀــﻊ ﺧــﻂ‬
‫اﻓﺘﺮاﺿــﻲ ﻣــﻦ ﻋﻨــﺪﻩ، وﻟﻼﺳــﻒ ﻻ اﺳــﺘﻄﻴﻊ ان اذآــﺮ ﺑﺎﻟﺘﺤﺪﻳــﺪ ﻣــﺎ هــﻮ اﻟﺨــﻂ اﻟــﺬي‬
‫ﺳﻴﺴﺘﺨﺪﻣﺔ ‪ Visual Basic‬ﻓﻬﻮ ﻳﺨﺘﻠـﻒ ﻣـﻦ ﺟﻬـﺎز اﻟـﻰ اﺧـﺮ. اﻣـﺎ ﺑﺎﻟﻨﺴـﺒﺔ ﻟﻠﺨﻄـﻮط‬
‫اﻟﺘـﻲ ﻻ ﺗﻨـﺪرج ﺗﺤـﺖ ﺗﻘﻨﻴـﺔ ‪ ،True Type‬ﻓـﺎن ﺣﺠـﻢ اﻟﺨـﻂ ‪ Font.Size‬ﻻ ﻳﺘـﻮﻓﺮ ﺑﻜـﻞ‬
‫اﻟﻤﻘﺎﺳﺎت، ﻓﻼ ﺗﺜـﻖ ﺑﺎﻟﻘﻴﻤـﺔ اﻟﺘـﻲ ارﺳـﻠﺘﻬﺎ اﻟـﻰ هـﺬﻩ اﻟﺨﺎﺻـﻴﺔ، ﻻن ‪Visual Basic‬‬
                                                                        ‫ﻳﻘﻮم ﺑﺘﻐﻴﻴﺮهﺎ:‬

‫"‪Label2.Font.Name = "MS SystemEx‬‬
‫02 = ‪Label2.Font.Size‬‬
‫اﻟﺤﺠﻢ 51 ‘ ‪Print Label2.Font.Size‬‬

‫اﺧﻴـــﺮا، ﺑﺎﻟﻨﺴـــﺒﺔ ﻟﻤﺒﺮﻣﺠـــﻲ ‪ Visual Basic‬اﻟﻤﺨﻀـــﺮﻣﻴﻦ ﻓﺎﻟﺨﺼـــﺎﺋﺺ اﻟﻘﺪﻳﻤـــﺔ‬
    ‫ـ‬   ‫ـ‬         ‫ـ ـ‬           ‫ـ‬     ‫ـ‬      ‫ـ‬
‫‪ .... FontBold ،FontSize ،FontName‬اﻟ ـﺦ، ﻣ ـﺎ زاﻟ ـﺖ ﻣﺪﻋﻮﻣ ـﺔ ﻓ ـﻲ 6‪ VB‬ﻣ ـﻊ ذﻟ ـﻚ،‬
                                            ‫اﻟﻜﺘﺎب ﻻ ﻳﻨﺎﻗﺶ ﺧﺼﺎﺋﺺ ﻏﻤﺴﻬﺎ اﻟﺘﺮاب.‬

                                                                ‫ﺧﺼﺎﺋﺺ اﻟﻠﻮن‬
‫اﻟﺨﺎﺻﻴﺘﺎن ‪ BackColor‬و ‪ ForeColor‬ﺗﻤـﺜﻼن ﻟـﻮن اﻟﺨﻠﻔﻴـﺔ وﻟـﻮن اﻟﺨـﻂ ﻟـﻸداة. ﺑﻌـﺾ‬
‫اﻻدوات آـ ‪ ScorllBar‬ﻻ ﺗﺪﻋﻢ هﺎﺗﺎن اﻟﺨﺎﺻﻴﺘﺎن، ﻓﺄﻟﻮاﻧﻬﺎ ﺗﻜﻮن ﻗﻴﺎﺳﻴﺔ ﻣﺴﺘﻮﺣﺎﻩ ﻣـﻦ‬
‫ﻧﻈﺎم اﻟﺘﺸﻐﻴﻞ. ﺑﻌﺾ اﻻدوات آـ ‪ Label‬ﻻ ﻳﻤﻜﻦ ان ﺗﻠﺤﻆ اﻟﺘﻐﻴﻴﺮ ﻓـﻲ ﻗﻴﻤـﺔ اﻟﺨﺎﺻـﻴﺔ‬
‫‪ BackColor‬اﻻ اذا آﺎﻧﺖ ﻗﻴﻤﺔ اﻟﺨﺎﺻﻴﺔ ‪ BackStyle‬ﺗﺴﺎوي ‪ .1-Opaque‬آـﺬﻟﻚ اﻟﺤـﺎل‬
‫ﻣﻊ زر اﻻواﻣﺮ ‪ ،CommandButton‬ﻓﻠﻦ ﺗﺘﻤﻜﻦ ﻣﻦ ﻣﺸﺎهﺪة اﻟﺘﻐﻴﻴـﺮ اﻟﻠـﻮﻧﻲ ﻟﺨﻠﻔﻴﺘـﻪ‬
‫اﻻ اذا ﺣﻮﻟـــﺖ ﻗﻴﻤـــﺔ ﺧﺎﺻـــﻴﺘﻪ ‪ Style‬اﻟـــﻰ ‪ 1–Graphical‬ﻣـــﻊ اﻟﻌﻠـــﻢ ان اﻟﺨﺎﺻـــﻴﺔ‬
                                                     ‫‪ ForeColor‬ﻟﻴﺴﺖ ﻣﺪﻋﻮﻣﺔ ﻓﻴﻪ.‬
‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻘﻴﻢ اﻻﻟﻮان ﻓﻤﻦ اﻻﻓﻀﻞ ان اﻗﺴﻤﻬﺎ ﻟـﻚ اﻟـﻰ ﻗﺴـﻤﻴﻦ: اﻻﻟـﻮان اﻟﻘﻴﺎﺳـﻴﺔ‬
‫‪ Standard Color‬واﻻﻟﻮان اﻟﺨﺎﺻـﺔ ‪ .Custom Color‬اﻻﻟـﻮان اﻟﻘﻴﺎﺳـﻴﺔ هـﻲ اﻟﻤﻔﻀـﻠﺔ‬
‫ﻓﻲ ﻣﻌﻈﻢ اﻻﺣﻮال ﻟﻼدوات ﻻﻧﻬﺎ اﻟﻮان ﻳﺤﺪدهﺎ اﻟﻤﺴﺘﺨﺪم ﻋﻦ ﻃﺮﻳـﻖ ﺧﺎﻧـﺔ اﻟﺘﺒﻮﻳـﺐ‬
‫‪ Appearance‬ﻓﻲ ﺻﻨﺪوق اﻟﺤﻮار ‪ Display Properties‬ﻣﻦ ﻟﻮﺣﺔ اﻟﺘﺤﻜﻢ، ﻓﻬﻲ اﻟـﻮان‬
‫ﺗﻨﺎﺳﺐ ﻣﺰاج اﻟﻤﺴـﺘﺨﺪم وﻳﺮﻳـﺪ ان ﺗﻈﻬـﺮ ﺟﻤﻴـﻊ ﺗﻄﺒﻴﻘـﺎت ‪ Windows‬ﺑﻬـﺬﻩ اﻻﻟـﻮان.‬
‫ﻟﺬﻟﻚ، ﻣﻦ اﺳﺎﻟﻴﺐ اﺣﺘﺮام ذوق اﻟﻤﺴﺘﺨﺪم هﻮ اﺳﺘﺨﺪام اﻻﻟـﻮان اﻟﺘـﻲ ﺗﻨﺎﺳـﺒﻪ ﻋـﻦ‬
                                                 ‫32‬


‫ﻃﺮﻳﻖ اﻻﻋﺘﻤﺎد ﻋﻠﻰ اﻻﻟﻮان اﻟﻘﻴﺎﺳﻴﺔ ‪ .Standard Color‬اﻣﺎ اﻟﻨﻮع اﻻﺧﺮ وهـﻮ اﻻﻟـﻮان‬
‫اﻟﺨﺎﺻــﺔ، ﻓﻬــﻲ اﻟــﻮان ﺳــﺘﺎﺗﻴﻜﻴﺔ أي ﺛﺎﺑﺘــﺔ ﻻ ﺗﺘﻐﻴــﺮ ﻣﻬﻤــﺎ ﻗــﺎم اﻟﻤﺴــﺘﺨﺪم ﺑﺘﻌــﺪﻳﻞ‬
  ‫ـ‬           ‫ـ‬       ‫ـ‬       ‫ـ‬   ‫ـ‬
‫ﺧﺼـﺎﺋﺺ ﺳـﻄﺢ ﻣﻜﺘﺒ ـﻪ، وان ﻟـﻢ ﺗﻜـﻦ ﻣﺼ ـﻤﻢ راﻗـﻲ ﻓـﻲ اﺧﺘﻴ ـﺎر اﻻﻟـﻮان اﻟﻤﻨﺎﺳ ـﺒﺔ‬
                                           ‫ـ‬       ‫ـ‬    ‫ـ‬        ‫ـ‬         ‫ـ‬        ‫ـ‬
‫ﻻدواﺗــﻚ، ﻓﺎﻧﺼــﺤﻚ ﺑﺎﻻﻧﺘﻘــﺎل اﻟــﻰ ﻓﻘــﺮة "ﺧﺼــﺎﺋﺺ اﻟﺠﺪوﻟــﺔ". اﻣــﺎ اذا آﻨــﺖ ﻣــﻦ‬
‫اﻟﻤﻌﺎﺷﺮﻳﻦ ﻟﻠﻴﻮﻧﺎردو داﻓﻨﺸﻲ او ﻣﺎﻳﻜـﻞ اﻧﺠﻠـﻮ، ﻓﺘﺴـﺘﻄﻴﻊ اﺳـﺘﺨﺪام ﻣﺠﻤﻮﻋـﺔ ﻣـﻦ‬
                                                            ‫اﻟﺜﻮاﺑﺖ ﺗﻤﺜﻞ ارﻗﺎم اﻻﻟﻮان:‬

‫‪Me.BackColor = vbGreen‬‬
‫‪Me.BackColor = vbBlue‬‬

‫او داﻟﺔ ‪ QBColor‬واﺳﺘﺨﺪام ﻧﻔﺲ اﻻﻋﺪاد اﻟﺘﻲ آﻨﺖ ﺗﺴـﺘﺨﺪﻣﻬﺎ ﻓـﻲ اﻳـﺎم ﻃﻔﻮﻟﺘـﻚ‬
                                                       ‫ﻣﻊ ﺑﻴﺌﺔ ‪:MS-DOS‬‬

‫اﺳﻮد ‘ )0( ‪Me.BackColor = QBColor‬‬
‫اﺑﻴﺾ ‘ )51( ‪Me.ForeColor = QBColor‬‬

                       ‫او داﻟﺔ ‪ RGB‬ﻣﻊ ﺗﺤﺪﻳﺪ اﻟﻌﻤﻖ اﻟﻠﻮﻧﻲ ﻟﻼﺣﻤﺮ، اﻻﺧﻀﺮ واﻻزرق:‬

‫)0 ,0 ,552( ‪Me.BackColor = RGB‬‬

‫وإن آﻨﺖ ﺗﺘﻤﺘﻊ ﺑﺬاآﺮة ﻗﻮﻳﺔ ﺟﺪا ﺟﺪا ﺟﺪا ﺗﺤﻔﻆ اآﺜﺮ ﻣﻦ 61 ﻣﻠﻴـﻮن ﻟـﻮن، ﻓﺘﺴـﺘﻄﻴﻊ‬
       ‫اﻻﺳﺘﻔﺎدة ﻣﻦ هﺬﻩ اﻟﺬاآﺮة ﻗﺒﻞ اﻟﺠﻨﻮن واﺳﺘﺨﺪم اﻟﺜﻮاﺑﺖ اﻟﻌﺪدﻳﺔ ﻣﺒﺎﺷﺮة:‬

‫2324324 = ‪Me.BackColor‬‬
‫ﻗﻴﻤﺔ ﺳﺖ ﻋﺸﺮﻳﺔ ‘ 2‪Me.ForeColor = &H53FF‬‬

‫آﻞ اﻟﻄﺮق اﻟﺴـﺎﺑﻘﺔ ﺗﻌﻤـﻞ ﺑﺸـﻜﻞ ﺟﻴـﺪ ﻓـﻲ وﻗـﺖ اﻟﺘﻨﻔﻴـﺬ وﺣﺘـﻰ وﻗـﺖ اﻟﺘﺼـﻤﻴﻢ،‬
‫ﻓﺘﺴﺘﻄﻴﻊ اﺳﺘﺨﺪام اﻟﺪوال اﻟﺴﺎﺑﻘﺔ ‪ QBColor‬و ‪ RGB‬ﻓﻲ ﺧﺎﻧﺔ آﺘﺎﺑﺔ ﻗﻴﻤﺔ ﺧﺼـﺎﺋﺺ‬
‫اﻻﻟﻮان ﻓﻲ ﺟﺪول ﻧﺎﻓﺬة اﻟﺨﺼﺎﺋﺺ، رﻏﻢ اﻧﻬـﺎ ﺗـﻮﻓﺮ ﻟـﻚ ﻟـﻮح اﻟـﻮان ﻳﻌﻄﻴـﻚ ﻓﻜـﺮة ﻋـﻦ‬
                                                         ‫ﻋﻤﻖ اﻟﻠﻮن ﻗﺒﻞ اﺧﺘﻴﺎرﻩ.‬

                                                              ‫ﺧﺼﺎﺋﺺ اﻟﺠﺪوﻟﺔ‬
‫ﻣﻌﻈﻢ ﻣﺴـﺘﺨﺪﻣﻲ ﺗﻄﺒﻴﻘـﺎت ‪ Windows‬ﻳﻔﻀـﻠﻮن اﺳـﺘﺨﺪام ﻣﻔﺘـﺎح اﻟﺠﺪوﻟـﺔ ]‪[TAB‬‬
‫ﻟﻠﺘﻨﻘﻞ ﺑﻴﻦ اﻻدوات. ﻣﻌﻈﻢ اﻻدوات اﻟﺘـﻲ ﻟﻬـﺎ ﻗﺎﺑﻠﻴـﺔ اﻧﺘﻘـﺎل اﻟﺘﺮآﻴـﺰ ‪ Focus‬ﻋﻠﻴﻬـﺎ –‬
                                               ‫42‬


‫آﺄداة اﻟﻨﺺ، ﺗﺤﺘﻮي ﻋﻠﻰ ﺧﺼﺎﺋﺺ اﻟﺠﺪوﻟﺔ ‪ TabStop‬و ‪ .TabIndex‬ﺣﺪد ﻋـﻦ ﻃﺮﻳـﻖ‬
‫اﻟﺨﺎﺻﻴﺔ ‪ TabStop‬ﻣﺎ اذا آﻨﺖ ﺗﺮﻳﺪ ﺟﻌﻞ اﻟﺘﺮآﻴـﺰ ﻳﻨﺘﻘـﻞ اﻟـﻰ اﻷداة ﺑﻤﺠـﺮد ان ﻳﻀـﻐﻂ‬
‫اﻟﻤﺴﺘﺨﺪم ﻋﻠﻰ اﻟﻤﻔﺘﺎح ]‪ ،[TAB‬ورﺗﺐ ﻓﻬﺮس اﻟﺘﺮآﻴﺰ ﻋﻦ ﻃﺮق اﻟﺨﺎﺻﻴﺔ ‪TabIndex‬‬
                       ‫ﻟﻜﻞ أداة، ﻣﻊ اﻟﻌﻠﻢ ان ﺗﺮﻗﻴﻢ اﻟﻔﻬﺮس ﻳﺒﺪأ ﻋﺎدة ﻣﻦ اﻟﺼﻔﺮ.‬

 ‫ﺣﺘﻰ ﻟﻮ آﺎﻧﺖ ﻗﻴﻤـﺔ اﻟﺨﺎﺻـﻴﺔ ‪ TabStop‬ﺗﺴـﺎوي ‪ False‬ﻟـﻸداة، ﻓـﺎن‬            ‫ﻣﻼﺣﻈﺔ:‬
 ‫اﻟﻤﺴﺘﺨﺪم ﻟﺪﻳـﻪ ﻓﺮﺻـﺔ اﺧـﺮى ﻟﻨﻘـﻞ اﻟﺘﺮآﻴـﺰ اﻟـﻰ اﻷداة ﻋـﻦ ﻃﺮﻳـﻖ‬
                                             ‫اﻟﻨﻘﺮ ﻋﻠﻴﻬﺎ ﺑﺰر اﻟﻔﺄرة.‬


                                                     ‫ﺧﺼﺎﺋﺺ ﻣﺆﺷﺮ اﻟﻔﺄرة‬
‫ﺧﺼــﺎﺋﺺ ﻣﺆﺷــﺮ اﻟﻔــﺄرة ‪ MousePointer‬و ‪ MouseIcon‬ﺗﺤــﺪدان اﻟﺸــﻜﻞ اﻟﻤﻄﻠــﻮب‬
‫ﻟﻤﺆﺷﺮ اﻟﻔﺄرة ‪ .Mouse Cursor‬ﺗﻮﻓﺮ ﻟﻚ اﻟﺨﺎﺻﻴﺔ ‪ 16 MousePointer‬ﻣﺆﺷـﺮ ﻗﻴﺎﺳـﻲ‬
‫ﻳﻮﻓﺮهــﺎ ﻧﻈــﺎم اﻟﺘﺸــﻐﻴﻞ، وإن رﻏﺒــﺖ ﻓــﻲ ﺗﺨﺼ ـﻴﺺ رﻣــﺰ ﻣﻌــﻴﻦ، ﻓــﺎﺧﺘﺮ اﻟﻘﻴﻤــﺔ -99‬
‫‪ Custom‬ﻣﻦ اﻟﺨﺎﺻﻴﺔ اﻟﺴﺎﺑﻘﺔ ﻣﻊ ﺗﺤﻤﻴﻞ ﻣﻠـﻒ اﻟﻤﺆﺷـﺮ ﻓـﻲ اﻟﺨﺎﺻـﻴﺔ ‪MouseIcon‬‬
                      ‫وﻗﺖ اﻟﺘﺼﻤﻴﻢ او اآﺘﺐ اﻟﻜﻮد اﻟﺘﺎﻟﻲ ﻻﺟﺮاء اﻟﻌﻤﻠﻴﺔ وﻗﺖ اﻟﺘﻨﻔﻴﺬ:‬

‫‪Command1.MousePointer = vbCustom‬‬
‫)”‪Command1.MouseIcon = LoadPicture (“C:\Test.ICO‬‬

‫ﻟﻦ ﺗﻼﺣﻆ ﺗﻐﻴﻴﺮ اﻟﻤﺆﺷﺮ اﻻ اذا ﻣﺮر اﻟﻤﺴـﺘﺨﺪم ﻣﺆﺷـﺮ اﻟﻔـﺄرة ﻓـﻮق اﻷداة. ﻣـﻊ ذﻟـﻚ،‬
‫هﻨﺎك ﻋﺪة ﻋﻮاﻣﻞ ﺗﻤﻨﻊ ‪ Visual Basic‬ﻣﻦ ﺗﻐﻴﻴﺮ ﺷﻜﻞ اﻟﻤﺆﺷـﺮ ان ﺗـﻢ ﺗﻐﻴﻴـﺮ اﻟﻤﺆﺷـﺮ‬
               ‫اﻟﻌﺎم ﻟﻠﺒﺮﻧﺎﻣﺞ واﻟﻤﺘﻤﺜﻞ ﻓﻲ اﻟﻜﺎﺋﻦ ‪ ،Screen‬ﺟﺮب هﺬا اﻟﻜﻮد ﻟﻠﺤﻈﺔ:‬

‫2 = ‪Screen.MousePointer‬‬
‫ﻟﻦ ﻳﺘﻐﻴﺮ ﺷﻜﻞ اﻟﻤﺆﺷﺮ اﺑﺪا ‘ 5 = ‪Command1.MousePointer‬‬

‫رﻏﻢ اﻧﻨﺎ ﺧﺼﺼﻨﺎ رﻣﺰ ﻣﻌﻴﻦ ﻟﺰر اﻻواﻣﺮ، اﻻ ان ‪ Visual Basic‬ﺗﺠﺎهﻞ ﺗﺨﺼﻴﺼﻨﺎ وآﺄﻧﻨـﺎ ﻻ‬
‫ﻧﻌﻨﻴﻪ ﺷﻴﺌﺎ، اﻟﺘﺠﺎهﻞ ﻣﻦ ‪ Visual Basic‬ﻟﻴﺲ اﻧﻘﺎص ﻓـﻲ ﺗﻘـﺪﻳﺮﻧﺎ او اﺣﺘﺮاﻣﻨـﺎ، واﻧﻤـﺎ‬
     ‫ﻓﻲ اﺳﻠﻮب ﺗﻌﺎﻣﻞ ‪ Visual Basic‬ﻣﻊ ﺧﺎﺻﻴﺔ ‪ MousePointer‬واﻟﺬي ﻳﻜﻮن آﺎﻟﺘﺎﻟﻲ:‬
‫- اذا آﺎﻧﺖ ﻗﻴﻤﺔ اﻟﺨﺎﺻﻴﺔ ‪ MousePointer‬اﻟﺘﺎﺑﻌـﺔ ﻟﻠﻜـﺎﺋﻦ ‪ Screen‬ﻏﻴـﺮ ‪،0-Default‬‬
‫ﻓــﺎن ‪ Visual Basic‬ﺳــﻴﺘﺠﺎهﻞ ﺟﻤﻴــﻊ ﺧﺼــﺎﺋﺺ ‪ MousePointer‬اﻟﺘﺎﺑﻌــﺔ ﻟﺴــﺎﺋﺮ‬
‫اﻻدوات ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ، وﺳﻴﻜﻮن ﺷﻜﻞ اﻟﻤﺆﺷﺮ هﻮ اﻟﺸﻜﻞ اﻟﺬي ﺗﺤﺪدﻩ ﻓﻲ هـﺬﻩ‬
                   ‫اﻟﺨﺎﺻﻴﺔ داﺋﻤﺎ واﺑﺪا اﻻ ﻓﻲ ﺣﺎﻟﺔ اﻧﺘﻘﺎل اﻟﻤﺆﺷﺮ اﻟﻰ ﺑﺮﻧﺎﻣﺞ اﺧﺮ.‬
                                              ‫52‬


‫- اذا آﺎﻧــﺖ اﻟﺨﺎﺻــﻴﺔ ‪ MousePointer‬اﻟﺘﺎﺑﻌــﺔ ﻟﻠﻜــﺎﺋﻦ ‪ Screen‬ﺗﺴــﺎوي ‪0-Default‬‬
‫وآﺎﻧﺖ اﻟﺨﺎﺻﻴﺔ ‪ MousePointer‬اﻟﺘﺎﺑﻌﺔ ﻟﻸداة ﻻ ﺗﺴـﺎوي ‪ ،0-Default‬ﻓـﺎن ﺷـﻜﻞ‬
     ‫اﻟﻤﺆﺷﺮ ﺳﻴﻜﻮن آﻤﺎ هﻮ ﻣﻄﻠﻮب ﻓﻲ اﻟﺨﺎﺻﻴﺔ ‪ MousePointer‬اﻟﺘﺎﺑﻌﺔ ﻟﻸداة.‬
‫- اﻣﺎ اذا آﺎﻧﺖ اﻟﺨﺎﺻﻴﺔ ‪ MousePointer‬اﻟﺘﺎﺑﻌﺔ ﻟﻠﻜـﺎﺋﻦ ‪ Screen‬ﺗﺴـﺎوي ‪0-Default‬‬
‫واﻟﺨﺎﺻــﻴﺔ ‪ MousePointer‬اﻟﺘﺎﺑﻌــﺔ ﻟــﻸداة ﺗﺴــﺎوي ‪ 0-Default‬اﻳﻀــﺎ، ﻓــﺎن ﺷــﻜﻞ‬
‫اﻟﻤﺆﺷﺮ ﺳﻴﻜﻮن آﻤـﺎ هـﻮ ﻣﻄﻠـﻮب ﻓـﻲ اﻟﺨﺎﺻـﻴﺔ ‪ MousePointer‬اﻟﺘﺎﺑﻌـﺔ ﻟﻨﺎﻓـﺬة‬
                                                                        ‫اﻟﻨﻤﻮذج.‬
‫ﻻ ﺗﻘﻢ ﺑﺘﻐﻴﻴﺮ ﺷﻜﻞ اﻟﻤﺆﺷﺮ اﻻ ﻋﻨـﺪ اﻟﺤﺎﺟـﺔ ﻟﺘﻐﻴﻴـﺮﻩ، آﺘﺤﻮﻳﻠـﻪ اﻟـﻰ ﺻـﻮرة ﻳـﺪ ﻋﻨـﺪ‬
‫اﻟﻤﺮور ﻓﻮق راﺑﻂ ﻟﻤﻮﻗﻊ ﻋﻠﻰ اﻻﻧﺘﺮﻧﺖ، او ﻋﻠﻰ ﺷﻜﻞ اﻻﺳـﻬﻢ ﻓـﻲ ﺣﺎﻟـﺔ اﻟﺘﺤﺠـﻴﻢ،‬
‫وﻣﻦ اﻟﻤﺴﺘﺤﺴﻦ ﺗﺤﻮﻳﻠﻪ اﻟﻰ ﺷﻜﻞ ﺳﺎﻋﺔ رﻣﻠﻴﺔ ﻋﻨﺪ ﺑﺪاﻳﺔ آـﻞ اﺟـﺮاء ﺣﺘـﻰ ﻳﻌﻠـﻢ‬
                                                         ‫اﻟﻤﺴﺘﺨﺪم ان ﻋﻠﻴﻪ اﻻﻧﺘﻈﺎر:‬

‫)(‪Private Sub Command1_Click‬‬
   ‫اﺟﺮاء ﺗﻨﻔﻴﺬﻩ ﻳﺴﺘﻐﺮق وﻗﺖ ‘‬
   ‫‪Screen.MouseIcon = vbHourglass‬‬

  ‫اآﻮاد اﻻﺟﺮاء ‘‬
  ‫…‬

  ‫ﻻ ﺗﻨﺴﻰ اﺳﺘﺮﺟﺎع اﻟﺸﻜﻞ اﻻﻓﺘﺮاﺿﻲ ‘‬
  ‫‪Screen.MousePointer = vbDefault‬‬
‫‪End Sub‬‬


                                         ‫ﺧﺎﺻﻴﺔ اﻟﺘﻌﺮﻳﺐ ‪RightToLeft‬‬
‫ﻣﻨﺬ 1‪ VB‬ﺣﺘﻰ 4‪ ،VB‬ﻃﺎل اﻧﺘﻈﺎر اﻟﻤﺒﺮﻣﺠﻴﻦ اﻟﻌﺮب ﻟﺨﺎﺻـﻴﺔ –وﻟـﻮ ﺑﺴـﻴﻄﺔ- ﺗﻤﻜـﻨﻬﻢ‬
‫ﻣﻦ ﺗﺤﻮﻳﻞ اﺗﺠﺎﻩ ادواﺗﻬﻢ اﻟﻰ اﻻﺗﺠﺎﻩ اﻟﻌﺮﺑـﻲ –ﻣـﻦ اﻟﻴﻤـﻴﻦ اﻟـﻰ اﻟﻴﺴـﺎر، وﺟـﺎء 5‪VB‬‬
‫ﺣﺎﻣﻼ اﻟﺒﺸﺮى اﻟﺴﻌﻴﺪة ﻟﻴﺰف اﻟـﻴﻬﻢ اﻟﺨﺎﺻـﻴﺔ ‪ RightToLeft‬اﻟﻤﺪﻋﻮﻣـﺔ ﻓـﻲ ﻣﻌﻈـﻢ‬
‫اﻻدوات –ﺣﺘــﻰ ﻧﺎﻓــﺬة اﻟﻨﻤــﻮذج. ﺻــﺤﻴﺢ ان اﻟﺨﺎﺻــﻴﺔ ‪ RightToLeft‬ﻻ ﺗﻄﺒــﻖ ﺗﻘﻨﻴــﺔ‬
‫اﻟﻤﺮﺁة، اﻻ اﻧﻬﺎ ﺣﻠﺖ ﻋﺸـﺮات اﻟﻤﺸـﺎآﻞ اﻟﺘـﻲ آﺎﻧـﺖ ﺗﻮاﺟـﻪ ﻣﺒﺮﻣﺠـﻲ ‪Visual Basic‬‬
                                                                      ‫اﻟﻤﺨﻀﺮﻣﻴﻦ.‬
                                               ‫62‬


 ‫ﺗﻘﻨﻴـﺔ اﻟﻤـﺮﺁة ﻇﻬـﺮت ﻣﻨـﺬ اﻻﺻـﺪار 89 ‪ Windows‬وهـﻲ ﺗﻘﻨﻴـﺔ ﺗﻘـﻮم‬          ‫ﻣﻼﺣﻈﺔ:‬
 ‫ﺑﻘﻠــﺐ ﺷــﻜﻞ ادوات ‪ Windows‬اﻟﻘﻴﺎﺳــﻴﺔ واﻟﺸــﺎﺋﻌﺔ اﻟــﻰ اﻻﺗﺠــﺎﻩ‬
 ‫اﻟﻌﺮﺑﻲ –ﻣﻦ اﻟﻴﻤـﻴﻦ اﻟـﻰ اﻟﻴﺴـﺎر. ﻃﺮﻳﻘـﺔ ﺗﻄﺒﻴﻘﻬـﺎ ﺗـﺘﻢ ﻋـﻦ ﻃﺮﻳـﻖ‬
 ‫اﻟﺨــﻮض ﻓــﻲ اﺟــﺮاءات ‪ API‬ﺧﺎﺻــﺔ، ﺳــﻨﺘﻌﺮف ﻋﻠﻴﻬــﺎ ﻓــﻲ اﻟﻔﺼــﻮل‬
                                             ‫اﻟﻼﺣﻘﺔ ﺑﻤﺸﻴﺌﺔ اﷲ.‬

‫ﻋﻠﻴﻚ اﻻﻧﺘﺒﺎﻩ اﻟـﻰ ان هـﺬﻩ اﻟﺨﺎﺻـﻴﺔ ﻻ ﺗﺘﺒـﻊ ﻣﻜﺘﺒـﺔ ‪ MSVBVM60.DLL‬واﻧﻤـﺎ ﻣﻜﺘﺒـﺔ‬
‫ﺧﺎﺻــﺔ ﺑﺘﻄﺒﻴﻘــﺎت اﻟﺸــﺮق اﻻوﺳــﻂ ﺗﻌــﺮف ﺑـــ ‪ ،VBAME.DLL‬اﻟﻐﺮﻳــﺐ ﻓــﻲ اﻣــﺮ هــﺬﻩ‬
‫اﻟﻤﻜﺘﺒﺔ هﻮ ﺿﺮورة وﺟﻮدهﺎ ﻓﻲ ﻣﺠﻠﺪ اﻟﻨﻈـﺎم ‪ System Directory‬ﺣﺘـﻰ ﺗﻌﻤـﻞ ﻣﻌـﻚ‬
‫ﺑﺸﻜﻞ ﺻﺤﻴﺢ، ﻓﻌﻨﺪﻣﺎ ﺗﻘﻮم ﺑﺘﻮزﻳﻊ ﺑﺮﻧﺎﻣﺠﻚ ﻋﻠﻰ اﺟﻬﺰة اﺧﺮى، ﻻ ﺗﺤﺎول وﺿﻌﻬﺎ ﻓﻲ‬
  ‫ـ‬       ‫ـ‬                ‫ـ‬        ‫ـ‬                ‫ـ‬    ‫ـ‬            ‫ـ‬
‫ﻧﻔـﺲ ﻣﺠﻠـﺪ اﻟﺒﺮﻧـﺎﻣﺞ ﻓـﺬﻟﻚ ﻟـﻦ ﻳﻔﻴـﺪك. اﻟﻘﻴﻤـﺔ ‪ True‬ﻟﻬـﺬﻩ اﻟﺨﺎﺻـﻴﺔ ﺗﺤـﻮل اﺗﺠـﺎﻩ‬
                          ‫اﻟﻨﺎﻓﺬة اﻟﻰ اﻻﺗﺠﺎﻩ اﻟﻌﺮﺑﻲ آﻤﺎ ﺗﻔﻌﻞ ذﻟﻚ ﻣﻊ اﻏﻠﺐ اﻻدوات.‬
‫اذا آﺎن ﻟﺪﻳﻚ ﻧﺎﻓﺬة ﻧﻤﻮذج ﻣﺼﻤﻤﺔ وادواﺗﻬﺎ ﻣﺮﺗﺒﺔ ﺑﺎﻻﺗﺠـﺎﻩ اﻟﻤﻌـﺎآﺲ ﻟﻠﻌﺮﺑـﻲ، ﻓﻬـﺬا‬
             ‫اﻟﻜﻮد ﻳﻮﻓﺮ ﻋﻠﻴﻚ ﻋﻨﺎء اﻋﺎدة ﺗﺮﺗﻴﺐ اﻻدوات ﻟﺘﻜﻮن ﻣﻦ اﻟﻴﻤﻴﻦ اﻟﻰ اﻟﻴﺴﺎر:‬

‫)(‪Private Sub Form_Load‬‬
   ‫‪Dim Ctrl As Control‬‬
   ‫‪On Error Resume Next‬‬

  ‫‪For Each Ctrl In Controls‬‬
     ‫‪If TypeOf Ctrl Is Line Then‬‬
        ‫1‪Ctrl.X1 = Ctrl.Container.ScaleWidth - Ctrl.X‬‬
        ‫2‪Ctrl.X2 = Ctrl.Container.ScaleWidth - Ctrl.X‬‬
     ‫‪Else‬‬
        ‫‪Ctrl.Left = Ctrl.Container.ScaleWidth - Ctrl.Left - Ctrl.Width‬‬
     ‫‪End If‬‬
     ‫‪If Ctrl.Alignment = 1 Then‬‬
        ‫0 = ‪Ctrl.Alignment‬‬
     ‫‪ElseIf Ctrl.Alignment = 0 Then‬‬
        ‫1 = ‪Ctrl.Alignment‬‬
     ‫‪End If‬‬
     ‫‪Ctrl.RightToLeft = True‬‬
  ‫‪Next‬‬
  ‫‪RightToLeft = True‬‬
  ‫‪Err.Clear‬‬
                                              ‫72‬


‫‪End Sub‬‬


                                                   ‫ﺧﺎﺻﻴﺔ اﻟﻤﻘﺒﺾ ‪hWnd‬‬
‫هﺬﻩ اﻟﺨﺎﺻﻴﺔ ﺗﻌﺘﺒﺮ ﻣـﻦ ﺧﺼـﺎﺋﺺ اﻟﻘـﺮاءة ﻓﻘـﻂ ‪ ،Read Only Propeties‬وهـﻲ ﻗﻴﻤـﺔ‬
‫ﻋﺪدﻳﺔ ﻃﻮﻳﻠﺔ ﻣﻦ اﻟﻨﻮع ‪ .Long‬ﺣﺘﻰ ﻟﻮ آﻨﺖ ﻣﻦ آﺒﺎر اﻟﻤﺤﺘـﺮﻓﻴﻦ ﻓـﻲ ‪،Visual Basic‬‬
‫ﻟﻦ ﺗﺴﺘﻄﻴﻊ اﻻﺳﺘﻔﺎدة ﻣﻦ هـﺬﻩ اﻟﺨﺎﺻـﻴﺔ اﻻ ﻋﻨـﺪ ﺗﻌﺎﻣﻠـﻚ ﻣـﻊ اﺟـﺮاءات ‪ API‬واﻟﺘـﻲ‬
‫ﺳﻨﻨﺎﻗﺸﻬﺎ ﻓﻲ اﻟﻔﺼﻮل اﻟﻼﺣﻘﺔ. وﺑﻤﺎ ان اﻟﻮﻗﺖ ﻣﺎزال ﻣﺒﻜﺮا ﺟﺪا ﻟﻠﺤﺪﻳﺚ ﻋﻨﻬﺎ، ﻓﺎود‬
‫ﺗﻮﺿــﻴﺢ ﻧــﻮﻋﻴﻦ ﻣــﻦ اﻻدوات هﻤــﺎ اﻻدوات اﻟﻘﻴﺎﺳــﻴﺔ ‪ Standard Controls‬واﻻدوات‬
                                ‫ﻣﻌﺪوﻣﺔ اﻟﻨﻮاﻓﺬ ‪ Windowless Controls‬او اﻟﻮهﻤﻴﺔ.‬
                 ‫ـ‬                ‫ـ‬    ‫ـ‬              ‫ـ‬       ‫ـ‬         ‫ـ‬
‫ﻋﻨ ـﺪﻣﺎ ﺗﻘ ـﻮم ﺑﺈﻧﺸ ـﺎء أداة ﻧ ـﺺ ‪ TextBox‬ﻣ ـﻦ ﺻ ـﻨﺪوق اﻻدوات، ﻳﻘ ـﻮم ‪Visual Basic‬‬
‫ﺑﺎﺟﺮاء ﻋﻤﻠﻴﺔ اﺗﺼﺎﻻت ﺳﺮﻳﺔ ﻣـﻊ ﻧﻈـﺎم اﻟﺘﺸـﻐﻴﻞ ‪ Windows‬ﻃﺎﻟﺒـﺎ ﻣﻨـﻪ ﻧﺴـﺨﺔ ﻣـﻦ‬
‫اﻷداة. آﺮم ﻧﻈﺎم اﻟﺘﺸﻐﻴﻞ ‪ Windows‬ﻳﺠﺒﺮﻩ ﻋﻠﻰ اﻟﻤﻮاﻓﻘﺔ، وﻳﻘﻮم ﺑﺎﻋﻄﺎء رﻗـﻢ ﻓﺮﻳـﺪ‬
‫ﻻ ﻳﺘﻜﺮر اﻟﻰ هﺬﻩ اﻷداة ﻳﻌﺮف ﺑﺎﻻﺳﻢ ﻣﻘـﺒﺾ اﻟﻨﺎﻓـﺬة ‪ .Window Handle‬هـﺬا اﻟـﺮﻗﻢ‬
‫ﻳﺘﻢ ﺣﻔﻈﻪ ﻓﻲ اﻟﺨﺎﺻﻴﺔ ‪ hWnd‬اﻟﺘﺎﺑﻌﺔ ﻟﻸداة. ﻣﻦ اﻟﻤﻬﻢ ان ﺗﻌﻠﻢ هﻨﺎ ﺑﺎن اﻟﻤﺴـﺆول‬
‫اﻻول واﻻﺧﻴــﺮ ﻋــﻦ هــﺬﻩ اﻷداة هــﻮ ﻧﻈــﺎم اﻟﺘﺸــﻐﻴﻞ وﻟــﻴﺲ ‪ ،Visual Basic‬ﻓﺠﻤﻴــﻊ‬
    ‫ـ‬        ‫ـ‬   ‫ـ‬                  ‫ـ‬      ‫ـ‬          ‫ـ‬          ‫ـ‬
‫اﻟﻌﻤﻠﻴـﺎت اﻟﺘﻨﺴـﻴﻘﻴﺔ او اﻟﺘـﻲ ﻳﻘـﻮم ﺑﻬـﺎ اﻟﻤﺴـﺘﺨﺪم ﻳﺘﻔﺎﻋـﻞ ﻣﻌﻬـﺎ ﻧﻈـﺎم اﻟﺘﺸـﻐﻴﻞ‬
‫وﻟـﻴﺲ ‪ ،Visual Basic‬ﻓـﺪور ‪ Visual Basic‬هﻨـﺎ اﺷـﺒﻪ ﺑـﺎﻟﻤﺘﺮﺟﻢ ﺑـﻴﻦ اﻟﻤﺒـﺮﻣﺞ وﺑـﻴﻦ‬
                                                        ‫ﻧﻈﺎم اﻟﺘﺸﻐﻴﻞ ‪.Windows‬‬
‫اﻣﺎ اﻻدوات ﻣـﻦ اﻟﻨـﻮع ‪ Windowless Controls‬ﻓﻬـﻲ ادوات وهﻤﻴـﺔ ﺧﺎﺻـﺔ ﺑﺒﺮاﻣﺠـﻚ‬
‫اﻟﻤﺼﻤﻤﺔ ﺗﺤﺖ ‪ Visual Basic‬وﻧﻈﺎم اﻟﺘﺸﻐﻴﻞ ﻻ ﻳﻌﻠﻢ أي ﺷﺊ ﻋﻨﻬـﺎ ﻣﺜـﻞ اﻻﻋﻤـﻰ،‬
                                             ‫واﻟﺪﻟﻴﻞ اﻧﻬﺎ ﻻ ﺗﻤﺘﻠﻚ اﻟﺨﺎﺻﻴﺔ ‪.hWnd‬‬
‫ﺟﻤﻴﻊ اﻻدوات اﻟﻤﻮﺟﻮدة ﻓﻲ ﺻﻨﺪوق اﻻدوات هﻲ ﻣﻦ اﻟﻨـﻮع اﻻول ﺑﺎﺳـﺘﺜﻨﺎء اﻻدوات:‬
‫‪ Line ،Shape ،Timer ،Label‬و ‪ Image‬ﻓﻬﻲ ادوات وهﻤﻴﺔ وﻻ ﺗﺤﺘﻮي ﻋﻠﻰ اﻟﺨﺎﺻﻴﺔ‬
‫‪ .hWnd‬ﺣﺎول اﻻآﺜﺎر ﻣﻦ هﺬا اﻟﻨـﻮع ﻣـﻦ اﻻدوات ﻓﻬـﻲ ﺗﺴـﺘﻬﻠﻚ اﻟﻘﻠﻴـﻞ ﻣـﻦ ﻣﺼـﺎدر‬
                ‫اﻟﻨﻈﺎم ‪ System Resources‬وﺗﻜﻮن اﺳﺮع ﺑﻜﺜﻴﺮ ﻣﻦ اﻻدوات اﻻﺧﺮى.‬
‫ﺑﺎﻟﻨﺴﺒﺔ ﻻدوات اﻟﺘﺤﻜﻢ ‪ ،ActiveX Controls‬ﻓﻤﻌﻈﻤﻬﺎ ﻣﻦ اﻟﻨﻮع ‪Standard Controls‬‬
‫وﻗﺪ ﺗﻜﻮن ﻣﻦ اﻟﻨﻮع ‪ .Windowless Controls‬وﻻ ﻳﻤﻜﻨﻚ ﻣﻌﺮﻓﺔ ﻧـﻮع أداة اﻟـﺘﺤﻜﻢ ﻋـﻦ‬
‫ﻃﺮﻳﻖ اﺧﺘﺒﺎر وﺟﻮد اﻟﺨﺎﺻﻴﺔ ‪ hWnd‬ﺑﻬﺎ، ﻓﻘﺪ ﺗﻜﻮن اﻷداة ﻣﻦ اﻟﻨﻮع اﻻول وﻟﻜﻦ ﻣﺼﻤﻢ‬
                           ‫اﻷداة ﻗﺪ اﺧﻔﻰ ﻇﻬﻮر اﻟﺨﺎﺻﻴﺔ ‪ hWnd‬ﻻﺳﺒﺎب ﺷﺨﺼﻴﺔ.‬

                                                             ‫ﺧﺼﺎﺋﺺ اﺧﺮى‬
‫ﻣﻦ اﻟﺨﺼﺎﺋﺺ اﻟﻤﺸﺘﺮآﺔ اﻻﺧﺮى ﺧﺎﺻﻴﺔ اﻟﺮؤﻳﺔ ‪ Visible‬اﻟﺘﻲ ﺗﻤﻜﻨﻚ ﻣﻦ اﺧﻔـﺎء اﻷداة‬
‫واﻻدوات اﻟﻤﺤﻀﻮﻧﺔ ﺑﻬﺎ ﻋﻦ ﻋـﻴﻦ اﻟﻤﺴـﺘﺨﺪم ﻟﻜﻨﻬـﺎ ﻇـﺎهﺮة ﻟﻌـﻴﻦ اﻟﻤﺒـﺮﻣﺞ، ﻓـﺎﻷداة‬
                                              ‫82‬


‫ﻣﻮﺟﻮدة ﻓﻲ اﻟﺬاآﺮة وﺑﺎﻣﻜﺎن اﻟﻤﺒﺮﻣﺞ اﻟﻮﺻﻮل اﻟﻴﻬﺎ ﺣﺘﻰ وان آﺎﻧـﺖ ﻣﺨﻔﻴـﺔ. ﺧﺎﺻـﻴﺔ‬
‫اﻟﺘﻤﻜﻴﻦ ‪ Enabled‬ﺗﻤﻨﻊ اﻟﻤﺴـﺘﺨﺪم ﻣـﻦ اﻟﺘﻔﺎﻋـﻞ ﻣـﻊ اﻷداة ﺳـﻮاء ﺑـﺎﻟﻨﻘﺮ او اﻟﻜﺘﺎﺑـﺔ‬
‫ﻋﻠﻴﻬﺎ وهﻲ ﺗﺆﺛﺮ اﻳﻀﺎ ﻋﻠﻰ اﻻدوات اﻟﻤﺤﻀﻮﻧﺔ ﺑﻬﺎ. اﻟﺨﺎﺻﻴﺔ ‪ Tag‬ﺗﺤﻔﻆ ﻗﻴﻤـﺔ ﺣﺮﻓﻴـﺔ‬
‫‪ String‬ﺗﻜﻮن ﻗﻴﻤﺔ اﺿﺎﻓﻴﺔ -ﻻ راﺣﺖ وﻻ ﺟﺖ- وﻻ ﺗﺆﺛﺮ ﺑﺎي ﺷﻜﻞ ﻣـﻦ اﻻﺷـﻜﺎل ﻋﻠـﻰ‬
‫ﺳﻠﻮك او ﻣﻈﻬﺮ اﻷداة. اﻟﺨﺎﺻﻴﺔ ‪ Index‬ﺗﺴﺘﺨﺪم ﻓﻲ ﺣﺎﻟﺔ ﻧﺴـﺦ اﻻدوات ﻟﺘﻜـﻮﻳﻦ ﻣـﺎ‬
‫ﻳﻌﺮف ﺑﻤﺼﻔﻮﻓﺔ اﻻدوات ‪ Control Array‬واﻟﺬي ﺳﻨﺘﻄﺮق اﻟﻴﻪ ﻓﻲ ﻓﺼـﻞ "اﻻﺳـﺘﺨﺪام‬
                                                                ‫اﻟﻤﺘﻘﺪم ﻟﻠﻨﻤﺎذج".‬
‫وﻣﻦ اﻟﺨﺼﺎﺋﺺ اﻟﺘﻲ ﺗﺆﺛﺮ ﻋﻠﻰ ﻣﻈﻬﺮ اﻷداة واﻟﻤﺪﻋﻮﻣـﺔ ﻋﻠـﻰ ﺑﻌـﺾ اﻻدوات ﺧﺎﺻـﻴﺔ‬
‫اﻟﻤﻈﻬــﺮ ‪ Appearance‬اﻟﺘــﻲ ﺗﻌﻄــﻲ ﻣﻈﻬــﺮ ﺛﻼﺛــﻲ اﻻﺑﻌــﺎد ‪ 3-D‬ﻟــﻸداة، واﻟﺨﺎﺻــﻴﺔ‬
‫‪ BorderStyle‬اﻟﺘﻲ ﺗﺨﻔﻲ او ﺗﻈﻬﺮ اﻟﺤـﺪود اﻟﺨﺎرﺟﻴـﺔ ﻟـﻸداة وأﻳﻀـﺎ ﺧﺎﺻـﻴﺔ اﻟﻤﺤـﺎذاة‬
‫‪ Align‬اﻟﺘﻲ ﺗﺤﺎذي اﻷداة ﺗﻠﻘﺎﺋﻴﺎ ﺣﺘﻰ ﻣﻊ ﺗﻐﻴﻴﺮ ﺣﺠﻢ اﻟﻨﺎﻓﺬة دون اﻟﺤﺎﺟﺔ اﻟـﻰ آﺘﺎﺑـﺔ‬
                                                                     ‫اآﻮاد اﺿﺎﻓﻴﺔ.‬
‫ﺗﻼﺣﻆ ﻓﻲ ﻣﻌﻈﻢ ﺗﻄﺒﻴﻘﺎت ‪ Windows‬ﻇﻬﻮر ﻣﺮﺑﻊ اﺻـﻔﺮ ﻋﻨـﺪﻣﺎ ﺗﻘـﻮم ﺑﺘﻮﺟﻴـﻪ ﻣﺆﺷـﺮ‬
‫اﻟﻔﺄرة اﻟﻰ أداة ﻣﻌﻴﻨﺔ واﻻﻧﺘﻈﺎر ﺑﻀﻊ ﺛﻮاﻧﻲ دون ﺗﺤﺮﻳﻚ اﻟﻤﺆﺷـﺮ، هـﺬا اﻟﻤﺮﺑـﻊ ﻳـﺪﻋﻰ‬
‫أداة اﻟﺘﻠﻤﻴﺢ ‪ ،ToolTip‬ﺑﺎﻣﻜﺎﻧﻚ ﺗﺨﺼﻴﺺ ﺗﻠﻴﻤﺢ ﻟﻜﻞ أداة ﻣﻮﺟﻮدة ﻓـﻲ ﻧﺎﻓـﺬة اﻟﻨﻤـﻮذج‬
                                                  ‫ﻋﻦ ﻃﺮﻳﻖ اﻟﺨﺎﺻﻴﺔ ‪.ToolTipText‬‬
‫اﺧﻴــﺮا، اﻟﺨﺼــﺎﺋﺺ اﻟﻘﺪﻳﻤــﺔ آﺨﺼــﺎﺋﺺ اﻟﺴــﺤﺐ واﻻﻟﻘــﺎء ‪ DragMode‬و ‪ DragIcon‬او‬
‫ﺧﺼﺎﺋﺺ اﻟﺮﺑﻂ اﻟﺪﻳﻨﺎﻣﻴﻜﻲ ‪ .... LinkItem ،LinkMode ،LinkTopic‬اﻟﺦ ﻣﻦ اﻟﺨﺼـﺎﺋﺺ‬
‫اﻟﺘﻲ ﻗﺪ ﺟﺎر ﻋﻠﻴﻬﺎ اﻟﺰﻣﻦ وﻃﻐﺖ ﻋﻠﻴﻬﺎ ﺗﻘﻨﻴﺎت اﻓﻀﻞ ﻣﻨﻬﺎ. اذا آﻨـﺖ ﻣﻀـﻄﺮ ﻟﺘﺤﻘﻴـﻖ‬
‫اﻟﺘﻮاﻓﻘﻴﺔ ‪ Compatibility‬ﻣﻊ ﺑﺮاﻣﺠـﻚ اﻟﻘﺪﻳﻤـﺔ، ﻓﻬـﻲ ﻣﺎزاﻟـﺖ ﻣﺪﻋﻮﻣـﺔ ﺑﺸـﻜﻞ ﺟﻴـﺪ‬
‫ﺟﺪا، اﻣﺎ هﺬا اﻟﻜﺘﺎب ﻓﻠﻦ ﻳﻨﻈﺮ اﻟﻰ اﻟﺨﻠﻒ اﺑﺪا وﻟﻦ ﻳﺬآﺮ هﺬﻩ اﻟﺨﺼﺎﺋﺺ ﺑﻌـﺪ اﻟﻨﻘﻄـﺔ‬
                                                                           ‫اﻟﺘﺎﻟﻴﺔ.‬


                                                               ‫اﻟﻄﺮق اﻟﻤﺸﺘﺮآﺔ‬
‫ﺑﻌﺪ اﻟﺨﺼﺎﺋﺺ ﺗﺄﺗﻲ اﻟﻄﺮق، اﻟﻄﺮق ﻋﺒﺎرة ﻋـﻦ اواﻣـﺮ ﺗﺮﺳـﻠﻬﺎ اﻟـﻰ اﻷداة ﻟﺘﺤﺮﻳﻜﻬـﺎ او‬
‫ﻧﻘﻞ اﻟﺘﺮآﻴﺰ إﻟﻴﻬﺎ. واﻟﻮاﻗﻊ ان اﻟﻄﺮق ‪ Methods‬هﻲ ﻋﺒﺎرة ﻋـﻦ دوال ‪ Functions‬ﺗﻌـﻮد‬
‫ﺑﻘﻴﻢ ﻣﻌﻴﻨﻪ، او اﺟﺮاءات ‪ Sub’s‬ﺗﻘﻮم ﺑﻮﻇﻴﻔﺔ ﻣﺎ وﻟﻜﻨﻬﺎ ﻻ ﺗﻌﻴﺪ أي ﻗﻴﻤـﺔ. وآﻤـﺎ ﺗﻮﺟـﺪ‬
                             ‫ﺎ‬
    ‫اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﺨﺼﺎﺋﺺ اﻟﻤﺸﺘﺮآﺔ ﺑﻴﻦ اﻻدوات، ﺗﻮﺟﺪ اﻳﻀً ﻋﺪة ﻃﺮق ﻣﺸﺘﺮآﺔ هﻲ:‬

                                                              ‫اﻟﻄﺮﻳﻘﺔ ‪Move‬‬
  ‫ـ‬                               ‫ـ‬        ‫ـ‬          ‫ـ‬       ‫ـ‬          ‫ـ‬
‫اذا آﺎﻧ ـﺖ اﻷداة ﺗ ـﺪﻋﻢ ﺧﺼ ـﺎﺋﺺ اﻟﻤﻮﻗ ـﻊ واﻟﺤﺠ ـﻢ ‪ Height ،Top ،Left‬و ‪ ،Width‬ﻓ ـﺎن‬
                              ‫اﻟﻄﺮﻳﻘﺔ ‪ Move‬ﻣﺪﻋﻮﻣﺔ ﺑﻬﺎ ﻻ ﻣﺤﺎﻟﺔ. ﻓﺎﻟﻜﻮد اﻟﺘﺎﻟﻲ:‬
                                             ‫92‬



‫001 = ‪Form1.Left‬‬
‫002 = ‪Form1.Top‬‬
‫003 = ‪Form1.Height‬‬
‫004 = ‪Form1.Width‬‬

‫ﻳﻘﻮم ﻳﺘﻔﺠﻴﺮ اﻟﺤﺪث ‪ 4 Form_Resize‬ﻣﺮات اﻟﻰ ﺟﺎﻧﺐ اﻧﻪ ﻳﺴـﺘﻬﻠﻚ 4 ﺳـﻄﻮر ﻣﻤﻠـﺔ‬
                   ‫ﺗﺆدي اﻟﻰ ﺑﻂء ﻓﻲ اﻟﺘﻨﻔﻴﺬ، ﻣﻦ هﻨﺎ ﺗﺒﺮز ﻣﻴﺰة اﻟﻄﺮﻳﻘﺔ ‪:Move‬‬

‫004 ,003 ,002 ,001 ‪Form1.Move‬‬

‫ﺟﻤﻴﻊ اﻟﻘﻴﻢ اﻟﻤﺮﺳﻠﺔ اﺧﺘﻴﺎرﻳﺔ ﺑﺎﺳﺘﺜﻨﺎء اﻟﻘﻴﻤـﺔ اﻻوﻟـﻰ، وﻻ ﺗﺴـﺘﻄﻴﻊ ارﺳـﺎل ﻗﻴﻤـﺔ‬
                                                  ‫دون ارﺳﺎل ﻗﻴﻤﺔ ﺳﺎﺑﻘﺔ ﻟﻬﺎ:‬

‫ﻣﻤﻜﻦ ﻋﻤﻞ ذﻟﻚ ‘ 002 ,001 ‪Form1.Move‬‬
‫اﻧﺴﻰ هﺬﻩ اﻟﻔﻜﺮة ‘ 003 , ,001 ‪Form1.Move‬‬


                                                       ‫اﻟﻄﺮﻳﻘﺔ ‪SetFocus‬‬
‫ﺗﻮﺟﻴﻪ اﻟﺘﺮآﻴﺰ اﻟـﻰ اﻷداة ﻳـﺘﻢ ﺑﺎﺳـﺘﺪﻋﺎء اﻟﻄﺮﻳﻘـﺔ ‪ SetFocus‬اﻟﺨﺎﺻـﺔ ﺑﻬـﺎ. اذا آﺎﻧـﺖ‬
  ‫ـ‬            ‫ـ‬                  ‫ـ‬                    ‫ـ‬
‫اﻷداة ﻣﺨﻔﻴـﺔ او ﻏﻴـﺮ ﻣﻤﻜﻨـﺔ، ﻓـﺎن هـﺬﻩ اﻟﻄﺮﻳﻘـﺔ ﺳﺘﺘﺴـﺒﺐ ﻓـﻲ وﻗـﻮع ﺧﻄـﺄ وﻗـﺖ‬
‫اﻟﺘﺸـﻐﻴﻞ ‪ .Run Time Error‬ﻟـﺬﻟﻚ، ﻳﻨﺼـﺢ ﺑـﺎﻟﺘﺤﻘﻖ ﻣـﻦ ﺧﺎﺻـﻴﺘﻲ اﻟﻈﻬـﻮر ‪Visible‬‬
                                    ‫واﻟﺘﻤﻜﻴﻦ ‪ Enabled‬ﻗﺒﻞ ﻧﻘﻞ اﻟﺘﺮآﻴﺰ اﻟﻰ اﻷداة:‬

‫‪If Text1.Visible = True And Text1.Enabled = True Then‬‬
   ‫‪Text1.SetFocus‬‬
‫‪End If‬‬

‫اذا آﻨﺖ ﺗﺮﻳﺪ ﻣﻨﻊ اﻟﻤﺴﺘﺨﺪم ﻣﻦ ﻧﻘﻞ اﻟﺘﺮآﻴﺰ اﻟﻰ أي أداة اﺧـﺮى ﻗﺒـﻞ ﺗﺤﻘـﻖ ﺷـﺮط‬
                                    ‫ﻣﻌﻴﻦ، ﻓﺎﻓﻀﻞ ﻣﻜﺎن هﻮ اﻟﺤﺪث ‪:LostFocus‬‬

‫)(‪Private Sub Text1_LostFocus‬‬
   ‫‪If Trim(Text1.Text) = "" Then‬‬
      ‫‪Text1.SetFocus‬‬
   ‫‪End If‬‬
‫‪End Sub‬‬
                                                 ‫03‬


‫اﻋﻴــﺪ واآــﺮر، ﻻ ﺗﺤــﺎول اﺳــﺘﺨﺪام هــﺬﻩ اﻟﻄﺮﻳﻘــﺔ اﻻ ﻓــﻲ ﺣﺎﻟــﺔ ﻇﻬــﻮر اﻷداة، ﻓﻠــﻮ‬
‫اﺳــﺘﺨﺪﻣﺘﻬﺎ ﻓــﻲ اﻟﺤــﺪث ‪ Form_Load‬ﻣــﺜﻼ، ﻋﻠﻴــﻚ اﻇﻬــﺎر اﻟﻨﺎﻓــﺬة ﻗﺒــﻞ اﺳــﺘﺨﺪام‬
                                                                             ‫اﻟﻄﺮﻳﻘﺔ:‬

‫)(‪Private Sub Form_Load‬‬
   ‫‪Me.Show‬‬
   ‫‪Text1.SetFocus‬‬
‫‪End Sub‬‬


                                                              ‫اﻟﻄﺮﻳﻘﺔ ‪ZOrder‬‬
‫ﻗﺪ ﺗﺤﺘﺎج اﻟﻰ اﻋﺎدة وﺿﻊ أداة ﻓـﻮق اﻻدوات او ﺧﻠـﻒ اﻻدوات وﻗـﺖ اﻟﺘﻨﻔﻴـﺬ، اﻟﻄﺮﻳﻘـﺔ‬
‫‪ ZOrder‬ﺗﻔﻲ ﺑﺎﻟﻐﺮض ﻟﻮﺿﻊ اﻷداة ﻓـﻮق اﻻدوات اﻻﺧـﺮى، وﻗـﺪ ﺗﺠﻌﻠﻬـﺎ ﺧﻠـﻒ اﻻدوات‬
                                               ‫اﺧﺮى ﻓﻲ ﺣﺎﻟﺔ ارﺳﺎل اﻟﻘﻴﻤﺔ 1:‬

‫اﻟﻘﻴﻤﺔ اﻻﻓﺘﺮاﺿﻴﺔ 0 ‘‬
‫‪Command1.Zorder‬‬      ‫ﻓﻮق ﺟﻤﻴﻊ اﻻدوات ‘‬
‫ﻓﻮق ﺟﻤﻴﻊ اﻻدوات ‘ 0 ‪Command1.Zorder‬‬
‫ﺧﻠﻒ ﺟﻤﻴﻊ اﻻدوات ‘ 1 ‪Command1.ZOrder‬‬

‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻼدوات ﻣﻌﺪوﻣﺔ اﻟﻨﻮاﻓﺬ ‪– Winodwless Controls‬آﺄداة اﻟﻌﻨﻮان ‪ -Label‬ﻓﺎﻧـﻪ‬
‫ﻣﻦ ﻋﺎﺷﺮ اﻟﻤﺴﺘﺤﻴﻼت ان ﺗﻈﻬـﺮ ﻓـﻮق أداة ﻗﻴﺎﺳـﻴﺔ ‪ .Standard Controls‬ﺗﺴـﺘﻄﻴﻊ‬
‫ان ﺗﻔﺘــﺮض ان ﻟﻠﻨﺎﻓــﺬة ﻃﺒﻘﺘــﻴﻦ، اﻻوﻟــﻰ ﺧﺎﺻــﺔ ﻟــﻼدوات اﻟﻘﻴﺎﺳــﻴﺔ واﻟﺜﺎﻧﻴــﺔ ﺧﺎﺻــﺔ‬
              ‫ـ ـ‬                 ‫ـ‬                  ‫ـ‬    ‫ـ‬           ‫ـ‬
‫ﻟـﻼدوات ﻣﻌﺪوﻣـﺔ اﻟﻨﻮاﻓـﺬ واﻟﺘـﻲ ﺗﻜـﻮن ﺧﻠـﻒ اﻟﻄﺒﻘـﺔ اﻻوﻟـﻰ داﺋﻤـﺎ. آـﺬﻟﻚ، اﻻدوات‬
‫اﻟﺤﺎﺿــﻨﺔ ﺗﻜــﻮن ﺧﻠــﻒ اﻻدوات اﻟﻤﺤﻀــﻮﻧﺔ ﺑﻬــﺎ. وﺑﺎﻟﻨﺴــﺒﺔ ﻟﻨﻮاﻓــﺬ اﻟﻨﻤــﺎذج، ﻓﻴﻤﻜﻨــﻚ‬
‫اﺳﺘﺨﺪام هﺬﻩ اﻟﻄﺮﻳﻘﺔ ﻟﻮﺿﻊ ﻧﺎﻓﺬة ﻧﻤﻮذج ﻓـﻮق اﻟﻨﻮاﻓـﺬ اﻻﺧـﺮى او ﺧﻠﻔﻬـﺎ، وﻟﻜـﻦ ﻻ‬
‫ﻳﻤﻜﻨﻚ ﺟﻌﻞ ﻧﺎﻓﺬة اﻟﻨﻤﻮذج ﻓﻲ ﻣﻘﺪﻣﺔ ﻧﻮاﻓﺬ ﺟﻤﻴﻊ ﺗﻄﺒﻴﻘﺎت ‪ Windows‬ﺑﺼﻮرة داﺋﻤﺔ‬
                                                              ‫ﺑﺎﺳﺘﺨﺪام هﺬﻩ اﻟﻄﺮﻳﻘﺔ.‬

                                                             ‫اﻟﻄﺮﻳﻘﺔ ‪Refresh‬‬
                         ‫ﺎ‬
‫هﺬﻩ اﻟﻄﺮﻳﻘﺔ ﺗﻄﻠﺐ ﻣﻦ اﻷداة اﻋﺎدة رﺳﻢ ﻧﻔﺴﻬﺎ. ﻋﻤﻠﻴً ﻟـﻦ ﺗﺤﺘـﺎج ﻻﺳـﺘﺪﻋﺎء هـﺬﻩ‬
‫اﻟﻄﺮﻳﻘﺔ آﺜﻴﺮا ﻓـ ‪ Visual Basic‬ﻳﻘﻮم ﺑﺮﺳﻢ اﻷداة ﺗﻠﻘﺎﺋﻴﺎ ﺑﻤﺠﺮد ﺗﻐﻴﻴﺮ ﻗـﻴﻢ ﺧﺼﺎﺋﺼـﻬﺎ.‬
    ‫اﻻ اﻧﻚ ﻗﺪ ﺗﺠﺒﺮ ‪ Visual Basic‬ﻹﻋﺎدة رﺳﻢ اﻷداة ﻓﻲ ﺣﺎﻻت اﻟﻀﻐﻂ اﻟﺸﺪﻳﺪ ﻋﻠﻴﻪ:‬

‫)(‪Private Sub Command1_Click‬‬
                                              ‫13‬


  ‫‪Dim X As Long‬‬

  ‫000001 ‪For X = 0 To‬‬
     ‫)‪Label1.Caption = CStr(X‬‬
     ‫‪Label1.Refresh‬‬
  ‫‪Next‬‬
‫‪End Sub‬‬

‫ﻗﺪ ﻳﻘﺘﺮح ﻋﻠﻲ اﺣﺪ ﻣﺒﺮﻣﺠﻲ ‪ Visual Basic‬اﻟﻘﺪﻣﺎء ﺑﺎﺳﺘﺨﺪام اﻟﺪاﻟﺔ ‪ .DoEvents‬ﻓﻲ‬
‫اﻟﺒﺪاﻳﺔ ﺳﺎﺷﻜﺮﻩ ﻋﻠﻰ اﻗﺘﺮاﺣﻪ اﻟﺬآﻲ وﻟﻜﻦ ﺳﺄرﻓﺾ اﻗﺘﺮاﺣـﻪ هﻨـﺎ ﻻن وﻇﻴﻔـﺔ هـﺬﻩ‬
‫اﻟﺪاﻟﺔ ﻟﻴﺴﺖ ﻣﻘﺼﻮرة ﻋﻠﻰ اﻋﺎدة اﻟﺮﺳﻢ ﻓﻘﻂ واﻧﻤﺎ ﺗﺘﻌﺪى هـﺬا اﻟـﺪور ﺑﻜﺜﻴـﺮ، ﻓﻬـﻲ‬
‫ﺧﺎﺻﺔ ﻟﻌﻤﻠﻴﺔ ﺗﻮزﻳﻊ اﻟﻤﻌﺎﻟﺠﺔ ‪ Processing‬ﻟﺒﺎﻗﻲ اﺟﺰاء اﻟﺒﺮﻧﺎﻣﺞ وﻟﻴﺲ اﻻدوات ﻓﻘـﻂ،‬
‫ﻣﻤﺎ ﻳﺆدي اﻟﻰ ﺑﻄﺊ ﻓﻲ اﻟﺴﺮﻋﺔ. ﻟﻴﺲ هﺬا ﻓﻘﻂ، ﺑﻞ ﻗﺪ ﺗﺆدي اﻟﻰ ﺷﻮاﺋﺐ ﺑﺮﻣﺠﻴﺔ‬
‫‪ ،Bugs‬ﻓﻬﻲ ﺗﻌﻄﻲ ﻓﺮﺻﺔ آﺒﻴﺮة ﻟﻠﻤﺴﺘﺨﺪم ﻻﻋـﺎدة اﻟﻀـﻐﻂ ﻋﻠـﻰ اﻟـﺰر 1‪Command‬‬
‫ﻣﺮة اﺧﺮى ﻗﺒﻞ ان ﻳﻨﺘﻬﻲ اﻻﺟﺮاء ﻣﻦ اآﻤﺎل اﻟﺤﻠﻘﺔ اﻟﺘﻜﺮارﻳﺔ اﻻوﻟـﻰ. ﻋﻠـﻰ اﻟﻌﻤـﻮم،‬
                                                          ‫ﺷﻜﺮا ﻋﻠﻰ اﻻﻗﺘﺮاح!‬


                                                            ‫اﻻﺣﺪاث اﻟﻤﺸﺘﺮآﺔ‬
‫ﻓﻠﺴﻔﺔ اﻟﺒﺮﻣﺠﺔ اﻟﻤﺴـﻴﺮة ﺑﺎﻻﺣـﺪاث ‪ Event Driven Programming‬ﺗﻘﺘﻀـﻲ ﻋﻤﻠﻴـﺔ‬
‫ﺗﻨﻔﻴﺬ اﻻآﻮاد ﻋﻨﺪ ﺣﺎﻻت ﻣﻌﻴﻨﺔ ﺗﻌﺮف ﺑﻮﻗﻮع اﻻﺣﺪاث او اﻧﻔﺠﺎر اﻻﺣﺪاث. ﻓﻌﻨﺪﻣﺎ ﺗﺼﻠﻚ‬
‫رﺳﺎﻟﺔ اﻣﺮ ﻣﻦ رﺋﻴﺴﻚ ﻓﻲ اﻟﻌﻤﻞ، ﻓـﺈن اﺳـﺘﺠﺎﺑﺘﻚ ﻟﻠﺤـﺪث ﺗﻜـﻮن ﺑﺘﻨﻔﻴـﺬ ﻣـﺎ ﻳﻄﻠـﺐ‬
‫ﻣﻨﻚ. آﺬﻟﻚ اﻟﺤﺎل ﻣﻊ اﻻدوات، ﻓﺎﻻآﻮاد اﻟﺘﻲ ﺗﻀـﻌﻬﺎ ﻟـﻦ ﻳـﺘﻢ ﺗﻨﻔﻴـﺬهﺎ اﻻ ﻋﻨـﺪ وﻗـﻮع‬
            ‫اﻟﺤﺪث ﻋﻠﻴﻬﺎ. واﻻﺣﺪاث ﻋﺒﺎرة ﻋﻦ اﺟﺮاءات ‪ Sub’s‬اﺳﻤﺎﺋﻬﺎ ﺗﺘﺒﻊ اﻟﺼﻴﻐﺔ:‬
‫اﺳﻢ اﻟﻜﺎﺋﻦ_اﻟﺤﺪث‬
‫)( ‪Form_Click‬‬
‫)( ‪Command1_Click‬‬

 ‫اﺳــﺘﺨﺪم اﻟﺘﻌﺒﻴــﺮ ﺗﻔﺠﻴــﺮ اﻟﺤــﺪث ‪ Fire Event‬ﻋﻮﺿــﺎ ﻋــﻦ اﻟﺘﻌﺒﻴــﺮ‬   ‫ﻣﻼﺣﻈﺔ:‬
 ‫اﺳﺘﺪﻋﺎء اﻟﺤﺪث، ﻓﺎﺳﺘﺪﻋﺎء اﻟﺤﺪث هﻲ ﻋﻤﻠﻴـﺔ آﺘﺎﺑـﺔ اﺳـﻢ اﻟﺤـﺪث‬
 ‫ﻟﺘﻨﻔﻴﺬﻩ آﻤـﺎ ﺗﻔﻌـﻞ ﻣـﻊ اﻻﺟـﺮاءات، اﻣـﺎ ﺗﻔﺠﻴـﺮ اﻟﺤـﺪث ﻓﻬـﻲ ﻋﻤﻠﻴـﺔ‬
 ‫اﺳﺘﺪﻋﺎء اﻟﺤﺪث ﻣﻦ ﻗﺒﻞ ﻧﻈﺎم اﻟﺘﺸﻐﻴﻞ و ‪ ،Visual Basic‬ﻓﺄرﺟﻮ ان ﻻ‬
 ‫ﺗﺘﻌﺠﺐ ﻣﻦ آﺜﺮة اﺳﺘﺨﺪاﻣﻲ ﻟﻬﺬا اﻟﻤﺼﻄﻠﺢ ﺣﺘﻰ ﻧﺰول اﺳﻤﻲ ﻓـﻲ‬
                           ‫اﻟﻘﺎﺋﻤﺔ اﻻﻣﺮﻳﻜﻴﺔ ﻟﻠﻤﺸﺘﺒﻪ ﻓﻴﻬﻢ ﺑﺎﻻرهﺎب!‬
                                             ‫23‬


‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻨﺎﻓﺬة اﻟﻨﻤﻮذج، ﺗﺴﻤﻴﺔ اﺣﺪاﺛﻬﺎ داﺋﻤﺎ ﻣـﺎ ﺗﺒـﺪأ ﺑﺎﻟﻜﻠﻤـﺔ ‪ Form‬وﻟـﻴﺲ اﺳـﻢ‬
‫اﻟﻨﻤﻮذج اﻟﻤﻮﺟﻮد ﻓﻲ اﻟﺨﺎﺻﻴﺔ ‪ .Name‬وآﻤﺎ ﻋﻠﻤﻨﺎ ﺑﻮﺟـﻮد ﺧﺼـﺎﺋﺺ وﻃـﺮق ﻣﺸـﺘﺮآﺔ‬
                            ‫ﺑﻴﻦ اﻻدوات، ﻓﺎن اﻻﺣﺪاث ﻻ ﺗﺸﺬ ﻋﻦ هﺬﻩ اﻟﻘﺎﻋﺪة:‬

                                                               ‫اﺣﺪاث اﻟﻔﺄرة‬
‫05% ﻣﻦ اآـﻮادك اﻟﻤﺴـﺘﺠﺎﺑﺔ ﺗﻜـﻮن ردة ﻓﻌـﻞ ﻻﻋﻤـﺎل دراﻣﻴـﺔ ﻗـﺎم ﺑﻬـﺎ اﻟﻤﺴـﺘﺨﺪم‬
‫ﺑﺎﻟﻔﺄرة. اول ﺣﺪث ﺗﻌﺮﺿﻪ ﻟـﻚ ﻣﻌﻈـﻢ اﻻدوات ﻋﻨـﺪ اﻟﻨﻘـﺮ اﻟﻤـﺰدوج ﻋﻠﻴﻬـﺎ هـﻮ اﻟﺤـﺪث‬
‫‪ Click‬واﻟﺬي ﻳﻨﻔﺠﺮ ﻓﻲ ﻟﺤﻈﺔ اﻟﻨﻘﺮ ﻋﻠﻰ اﻷداة ﺑﺰر اﻟﻔﺄرة اﻻﻳﺴـﺮ. واﻟﺤـﺪث ‪DblClick‬‬
‫ﻳﻤﺜﻞ اﻟﻨﻘﺮ اﻟﻤﺰدوج. ﻻ ﺗﺜﻖ آﺜﻴﺮا ﻓﻲ اﻟﺤﺪث ‪ Click‬وﺗﻌﺘﻘﺪ اﻧﻪ ﻻ ﻳﻨﻔﺠﺮ اﻻ ﻓـﻲ ﺣﺎﻟـﺔ‬
‫اﻟﻨﻘﺮ ﺑﺰر اﻟﻔﺄرة اﻻﻳﺴﺮ، ﻓﻌﻨﺪ ﻗﻴﺎﻣﻚ ﺑﺘﻐﻴﻴﺮ ﻗﻴﻤﺔ اﻟﺨﺎﺻﻴﺔ ‪ Value‬ﻟﻼداﺗـﻴﻦ ‪CheckBox‬‬
‫و ‪ ،OptionButton‬ﻳﻘﻮم ‪ Visual Basic‬ﺗﻠﻘﺎﺋﻴﺎ ﺑﺘﻔﺠﻴﺮ اﻟﺤﺪث ‪ Click‬اﻟﺘﺎﺑﻊ ﻟﻸداة. ﻧﻔﺲ‬
‫اﻻﻧﻔﺠﺎر ﻳﺤـﺪث ﻋﻨـﺪﻣﺎ ﺗﻘـﻮم ﺑﺘﻐﻴﻴـﺮ اﻟﺨﺎﺻـﻴﺔ ‪ ListIndex‬اﻟﺘﺎﺑﻌـﺔ ﻟﻼداﺗـﻴﻦ ‪ ListBox‬و‬
                                                                      ‫‪.ComboBox‬‬
‫ﻣﻦ اﻻﺳﺎﻟﻴﺐ اﻟﺨﺎﻃﺌﺔ اﻟﺘﻲ ﻳﺘﺒﻌﻬﺎ ﻗﻠﻴﻞ ﻣﻦ اﻟﻤﺒـﺮﻣﺠﻴﻦ هـﻲ آﺘﺎﺑـﺔ اآـﻮاد ﻓـﻲ آـﻼ‬
‫اﻟﺤـﺪﺛﻴﻦ ‪ Click‬و ‪ DblClick‬ﻟـﻨﻔﺲ اﻷداة، رﻏـﻢ اﻧـﻚ ﺗﺴـﺘﻄﻴﻊ ﻋﻤـﻞ ذﻟـﻚ ﺑــ ‪Visual‬‬
‫‪ ،Basic‬اﻻ اﻧﻬﺎ ﻃﺮﻳﻘﺔ ﻏﻴﺮ ﻣﺮﻧﺔ ﺗﺴﺒﺐ اﻟﺘﺸﻮﻳﺶ ﻋﻠﻰ ﻣﺴﺘﺨﺪم ﺑﺮﻧﺎﻣﺠﻚ ﺗﺆدي ﺑـﻪ‬
‫اﻟـﻰ اﻻﺳـﺘﻐﻨﺎء ﻋـﻦ اﻟﻔـﺄرة. ﻓﻠـﻮ ﻗـﺎم اﻟﻤﺴـﺘﺨﺪم ﺑـﺎﻟﻨﻘﺮ اﻟﻤـﺰدوج ﻋﻠـﻰ اﻷداة، ﻓـﺎن‬
‫اﻟﺤﺪث ‪ Click‬ﺳﻴﺘﻢ ﺗﻨﻔﻴـﺬﻩ اوﻻ وﻣـﻦ ﺛـﻢ ﺗﻨﻔﻴـﺬ اﻟﺤـﺪث ‪ .DblClick‬اذا آـﺎن ﻻﺑـﺪ ﻣـﻦ‬
‫اﺳﺘﺨﺪام اﻟﺤﺪﺛﻴﻦ ﻓﻲ أداة واﺣﺪة، ﻓﺎﺗﻤﻨﻰ ﻣﻦ ﺻﻤﻴﻢ ﻗﻠﺒﻲ ﻣﻌﺮﻓﺔ اﻟﺤﺪث اﻟﻤﻘﺼـﻮد‬
                                 ‫ﻗﺒﻞ ﺗﻨﻔﻴﺬﻩ ﺣﺘﻰ ﻻ ﻳﺴﺘﻐﻨﻲ اﻟﻤﺴﺘﺨﺪم ﻋﻦ ﻓﺄرﺗﻪ:‬

‫ﻣﺘﻐﻴﺮ ﻋﺎم ‘ ‪Dim bDblClick As Boolean‬‬

‫)(‪Private Sub Form_Click‬‬
    ‫‪Dim X As Single‬‬
     ‫‪bDblClick = False‬‬
 ‫اﻋﻄﺎء ﻣﻬﻠﺔ ﻧﺼﻒ ﺛﺎﻧﻴﺔ ‘‬
    ‫‪X = Timer‬‬
    ‫‪Do‬‬
        ‫‪DoEvents‬‬
        ‫‪If bDblClick Then Exit Sub‬‬
    ‫5.0 + ‪Loop Until Timer > X‬‬

‫اآﺘﺐ اﻻآﻮاد هﻨﺎ ‘‬
‫... ‘‬
                                              ‫33‬


‫‪End Sub‬‬

‫)(‪Private Sub Form_DblClick‬‬
   ‫‪bDblClick = True‬‬

‫اآﺘﺐ اﻻآﻮاد هﻨﺎ ‘‬
‫... ‘‬

‫‪End Sub‬‬

‫اذا آﻨﺖ ﺗﺮﻳﺪ ﻣﻌﺮﻓﺔ اﻟﻤﺰﻳﺪ ﻣﻦ اﻟﺘﻔﺎﺻﻴﻞ ﺣﻮل ﻋﻤﻠﻴﺔ اﻟﻨﻘﺮ اﻟﺘﻲ ﻗﺎم ﺑﻬﺎ اﻟﻤﺴﺘﺨﺪم،‬
‫آﻤﻮﻗﻊ ﻣﺆﺷﺮ اﻟﻔﺄرة او اﻟﺰر اﻟﺬي اﺳﺘﺨﺪﻣﻪ اﻟﻤﺴـﺘﺨﺪم ﺳـﻮاء اﻻﻳﻤـﻦ او اﻻﻳﺴـﺮ ....‬
                   ‫ـ‬         ‫ـ‬      ‫ـ‬
‫اﻟـ ـﺦ ﻣـ ـﻦ ﺗﻔﺎﺻـ ـﻴﻞ دﻗﻴﻘـ ـﺔ، ﻓﻴﺴـ ـﺮﻧﻲ ان اﻋـ ـﺮض ﻋﻠﻴـ ـﻚ اﻻﺣـ ـﺪاث ‪،MouseDown‬‬
                                              ‫ـ‬         ‫ـ‬        ‫ـ‬      ‫ـ‬     ‫ـ‬
‫‪ MouseMove‬و ‪ MouseUp‬اﻟﺘﻲ ﺗﻌﻄﻴﻚ ﺗﻔﺎﺻﻴﻞ اآﺜﺮ ﻋﻦ ﻋﻤﻠﻴﺎت اﻟﻔﺄرة ﻋﻠﻰ ﺷـﻜﻞ‬
            ‫ـ‬          ‫ـ‬                 ‫ـ‬
‫ﻣﺘﻐﻴـﺮات ﻣﺮﺳ ـﻠﺔ هـﻲ: ﻧ ـﻮع اﻟـﺰر اﻟﻤﺴ ـﺘﺨﺪم ‪ ،Button‬اﻟﻤﻔـﺎﺗﻴﺢ اﻟﻤﻀ ـﻐﻮﻃﺔ ‪،Shift‬‬
                                                  ‫ـ‬    ‫ـ‬     ‫ـ‬     ‫ـ‬       ‫ـ‬
                         ‫اﻻﺣﺪاﺛﻲ اﻟﺴﻴﻨﻲ ﻟﻠﻤﺆﺷﺮ ‪ X‬واﻻﺣﺪاﺛﻲ اﻟﺼﺎدي ﻟﻠﻤﺆﺷﺮ ‪.Y‬‬
‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﺰر اﻟﻤﺴﺘﺨﺪم ‪ ،Button‬ﻓﻘـﺪ ﻳﻜـﻮن اﻟـﺰر اﻻﻳﻤـﻦ و/او اﻻﻳﺴـﺮ و/او اﻻوﺳـﻂ‬
                ‫ﻟﻠﻔﺄرة، هﺬا اﻟﻤﺜﺎل ﻳﻌﻄﻴﻚ ﻓﻜﺮة ﻋﻦ ﻃﺮﻳﻘﺔ ﻣﻌﺮﻓﺔ اﻻزرار اﻟﻤﻀﻐﻮﻃﺔ:‬

‫_ ,‪Private Sub Form_MouseDown(Button As Integer, Shift As Integer‬‬
               ‫)‪X As Single, Y As Single‬‬
   ‫‪If Button And vbLeftButton Then‬‬
      ‫اﻟﺰر اﻻﻳﺴﺮ ﻣﻀﻐﻮط '‬
   ‫‪End If‬‬
   ‫‪If Button And vbRightButton Then‬‬
      ‫اﻟﺰر اﻻﻳﻤﻦ ﻣﻀﻐﻮط '‬
   ‫‪End If‬‬
   ‫‪If Button And vbMiddleButton Then‬‬
      ‫اﻟﺰر اﻻوﺳﻂ ﻣﻀﻐﻮط '‬
   ‫‪End If‬‬
‫‪End Sub‬‬

‫اﻣﺎ اﻟﻤﻔﺘﺎح اﻟﻤﻀﻐﻮط ‪ ،Shift‬ﻓﻬﻮ ﻧﻔﺲ اﻟﻤﺘﻐﻴﺮ ‪ Shift‬اﻟﺨﺎص ﺑﺎﺣـﺪاث ﻟﻮﺣـﺔ اﻟﻤﻔـﺎﺗﻴﺢ‬
‫‪ KeyUp‬و ‪ KeyDown‬واﻟﻤﺜﺎل اﻟﺘﻄﺒﻴﻘﻲ ﻟﻠﺘﻌﺎﻣﻞ ﻣﻌﻪ ﻣﻮﺟﻮد ﻓﻲ ﻓﻘﺮة "اﺣﺪاث ﻟﻮﺣـﺔ‬
‫اﻟﻤﻔﺎﺗﻴﺢ" اﻟﺘﻲ ﺳﺘﺼﻞ اﻟﻴﻬـﺎ ﻗﺮﻳﺒـﺎ. وﺑﺎﻟﻨﺴـﺒﺔ ﻟﻼﺣـﺪاﺛﻴﺎت ‪ X‬و ‪ Y‬ﻓﻬـﻲ ﺗﻤﺜـﻞ ﻣﻮﻗـﻊ‬
‫ﻣﺆﺷﺮ اﻟﻔﺄرة ﺑﺎﻟﻨﺴـﺒﺔ ﻟـﻸداة ﻧﻔﺴـﻬﺎ وﻟـﻴﺲ اﻟﺸﺎﺷـﺔ، ﺣﻴـﺚ ﺗﻤﺜـﻞ اﻟﻨﻘﻄـﺔ )0، 0(‬
                                               ‫43‬


‫اﻟﺰاوﻳﺔ اﻟﻌﻠﻮﻳﺔ اﻟﻴﺴﺮى ﻟﻸداة، وﺗـﺰداد ﻗﻴﻤـﺔ ‪ X‬آﻠﻤـﺎ اﺗﺠـﻪ ﻣﺆﺷـﺮ اﻟﻔـﺄرة اﻟـﻰ ﺟﻬـﺔ‬
                         ‫اﻟﻴﻤﻴﻦ وﺗﺰداد ﻗﻴﻤﺔ ‪ Y‬آﻠﻤﺎ اﺗﺠﻪ ﻣﺆﺷﺮ اﻟﻔﺄرة اﻟﻰ اﻻﺳﻔﻞ.‬
‫ﻳﺘﻢ ﺗﻔﺠﻴﺮ اﻟﺤﺪث ‪ MouseMove‬ﺑﻤﺠـﺮد ان ﻳﻘـﻮم اﻟﻤﺴـﺘﺨﺪم ﺑﺘﺤﺮﻳـﻚ اﻟﻤﺆﺷـﺮ ﻓـﻮق‬
‫اﻷداة، وﻧﻬﺎﻳﺔ اﻟﺤـﺪث ﺗﻜـﻮن ﻟﺤﻈـﺔ ﺧـﺮوج اﻟﻤﺆﺷـﺮ ﻋـﻦ ﺣـﺪود اﻷداة. اﻣـﺎ ﻓـﻲ ﺣﺎﻟـﺔ‬
‫اﻻﻟﺘﻘﺎط ‪ Capturing‬ﻓﺎن اﻟﺤﺪث ‪ MouseMove‬ﺳﻴﺘﻢ ﺗﻔﺠﻴﺮﻩ ﺣﺘﻰ ﻟﻮ ﺗﻌـﺪى اﻟﻤﺆﺷـﺮ‬
‫ﺣﺪود اﻷداة ﻣﻤﺎ ﻳﺘﺮﺗﺐ ﻋﻨﻪ ﻗﻴﻢ ﺳﺎﻟﺒﺔ ﻟﻼﺣﺪاﺛﻴﺎت ‪ X‬و ‪ Y‬ﻓﻲ ﺣﺎﻟﺔ آﻮن ﻣﺆﺷﺮ اﻟﻔﺄرة‬
                                                         ‫زﺣﻒ ﻳﺴﺎر او ﻓﻮق اﻷداة.‬

 ‫اﻟﻤﻘﺼﺪ ﻣﻦ آﻠﻤﺔ اﻻﻟﺘﻘﺎط ‪ Capturing‬هﻲ ﻋﻤﻠﻴﺔ اﻟﻀـﻐﻂ ﺑـﺰر اﻟﻔـﺄرة‬           ‫ﻣﻼﺣﻈﺔ:‬
                            ‫ﻋﻠﻰ اﻷداة ﻣﻊ اﺳﺘﻤﺮار اﻟﻀﻐﻂ ﻋﻠﻰ اﻟﺰر.‬

‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﺤﺪﺛﻴﻦ ‪ MouseDown‬و ‪ MouseUp‬ﻓﺴﻴﺘﻢ ﺗﻔﺠﻴﺮهﻤﺎ ﺑﻤﺠﺮد اﻟﻀﻐﻂ ﻋﻠـﻰ‬
‫زر اﻟﻔﺄرة و ﺗﺤﺮﻳﺮ اﻟﺰر ﻋﻠﻰ اﻟﺘﻮاﻟﻲ ﺣﺘﻰ ﻟﻮ اﺧﺘﻠﻔﺖ اﻻزرار، ﻓﻠﻮ ﻗﻤـﺖ ﺑﺎﻟﻀـﻐﻂ ﻋﻠـﻰ‬
‫زر اﻟﻔﺄرة اﻻﻳﺴﺮ –وأﺑﻘﻴﺘﻪ ﻣﻀﻐﻮﻃﺎ- وﻣـﻦ ﺛـﻢ ﻗﻤـﺖ ﺑﺎﻟﻀـﻐﻂ ﻋﻠـﻰ زر اﻟﻔـﺄرة اﻻﻳﻤـﻦ،‬
‫ﻓﺴﻴﻘﻮم ‪ Visual Basic‬ﺑﺘﻔﺠﻴﺮ اﻟﺤﺪث ‪ MouseDown‬ﻣﺮﺗﻴﻦ، وﻋﻨﺪ ﺗﺤﺮﻳـﺮ اﻻزرار، ﻓـﺎن‬
                                             ‫اﻧﻔﺠﺎرﻳﻦ ﻟﻠﺤﺪث ‪ MouseUp‬ﻣﻘﺒﻼن.‬

‫اﺧﻴﺮا، ﻓـﻲ ﺣﺎﻟـﺔ ﻗﻴـﺎم اﻟﻤﺴـﺘﺨﺪم ﺑـﺎﻟﻨﻘﺮ اﻟﻤـﺰدوج ‪ Double Click‬ﻋﻠـﻰ اﻷداة، ﻓـﺎن‬
                            ‫ﺗﺮﺗﻴﺐ وﻗﻮع او اﻧﻔﺠﺎر اﻻﺣﺪاث ﻳﺘﻢ ﻋﻠﻰ اﻟﻨﺤﻮ اﻟﺘﺎﻟﻲ:‬
‫‪MouseUp <- DblClick <- MouseMove <- Click <- MouseUp <- MouseDown‬‬
                                                    ‫-< ‪ MouseMove‬ﻣﺮة اﺧﺮى.‬

                                                                 ‫اﺣﺪاث اﻟﺘﺮآﻴﺰ‬
                                                    ‫ـ‬
‫ﻳ ـﺘﻢ ﺗﻔﺠﻴــﺮ اﻟﺤــﺪث ‪ GotFocus‬ﻋﻨ ـﺪﻣﺎ ﺗﺴــﺘﻘﺒﻞ اﻷداة اﻟﺘﺮآﻴــﺰ، واﻟﺤــﺪث ‪LostFocus‬‬ ‫ـ‬
‫ﻋﻨﺪﻣﺎ ﺗﻔﻘﺪ اﻷداة اﻟﺘﺮآﻴﺰ، ﺳﻮاء آـﺎن ذﻟـﻚ ﺑﺎﻟﻔـﺄرة او ﻟﻮﺣـﺔ اﻟﻤﻔـﺎﺗﻴﺢ أو ﺑﺮﻣﺠﻴـﺎ. أﻣـﺎ‬
‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻨﺎﻓﺬة اﻟﻨﻤﻮذج، ﻓﻬﺬﻩ اﻻﺣﺪاث ﺗﻌﻤﻞ ﺟﻴﺪا ﺑﻬـﺎ ﺷـﺮﻳﻄﺔ ﻋـﺪم وﺟـﻮد أي أداة‬
                                                              ‫ﻗﺎﺑﻠﺔ ﻻﺳﺘﻘﺒﺎل اﻟﺘﺮآﻴﺰ.‬

 ‫ﻟﻦ ﺗﺘﻢ ﻋﻤﻠﻴﺔ ﺗﻔﺠﻴﺮ اﻻﺣـﺪاث ﺑﺎﻟﻄﺮﻳﻘـﺔ اﻟﻤﺘﻮﻗﻌـﺔ اذا ﻓﻘـﺪت اﻟﻨﺎﻓـﺬة‬       ‫ﻣﻼﺣﻈﺔ:‬
 ‫ﺗﺮآﻴﺰهﺎ ﺑﺴﺒﺐ اﻻﻧﺘﻘﺎل اﻟـﻰ ﺗﻄﺒﻴـﻖ اﺧـﺮ او اﺳـﺘﻘﺒﻠﺖ ﺗﺮآﻴﺰهـﺎ ﺑﻌـﺪ‬
 ‫اﻻﻧﺘﻘﺎل ﻣﻦ ﺗﻄﺒﻴـﻖ اﺧـﺮ. ﺑﺎﺧﺘﺼـﺎر، اﺣـﺪاث اﻟﺘﺮآﻴـﺰ ﻻ ﺗﻌﻤـﻞ اﻻ ﺑـﻴﻦ‬
                                          ‫ﻧﻮاﻓﺬ وادوات ﺑﺮﻧﺎﻣﺠﻚ ﻓﻘﻂ.‬
                                             ‫53‬


                                                   ‫اﺣﺪاث ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﻴﺢ‬
‫ﺛﻼﺛﺔ اﺣﺪاث ﻣﺮﻧﺔ ﻳﻮﻓﺮهﺎ ﻟﻚ ‪ Visual Basic‬ﻧﺎﺗﺠﺔ ﻣﻦ ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﻴﺢ هﻲ ‪،KeyPress‬‬
‫‪ KeyDown‬و ‪ .KeyUp‬ﻓﻌﻨﺪﻣﺎ ﻳﻘﻮم اﻟﻤﺴـﺘﺨﺪم ﺑﺎﻟﻀـﻐﻂ ﻋﻠـﻰ أي زر ﻣـﻦ ازرار ﻟﻮﺣـﺔ‬
‫اﻟﻤﻔﺎﺗﻴﺢ، ﻓﺎﻟﺤﺪث ‪ KeyDown‬ﺳﻴﺘﻢ ﺗﻔﺠﻴﺮﻩ، ﺛﻢ ﻳﻘﻮم ‪ Visual Basic‬ﺑﺘﺤﻮﻳﻞ اﻟﻤﻔﺘـﺎح‬
‫اﻟﻤﺪﺧﻞ اﻟﻰ ﻣﻘﺎﺑﻠﻪ ﻓـﻲ ﺟـﺪول ‪ ASCII‬ﺛـﻢ ﻳـﺘﻢ ﺗﻔﺠﻴـﺮ اﻟﺤـﺪث ‪ ،KeyPress‬وﺑﻌـﺪ ان‬
                   ‫ﻳﺮﻓﻊ اﻟﻤﺴﺘﺨﺪم اﺻﺒﻌﻪ ﻋﻦ اﻟﻤﻔﺘﺎح ﻳﺒﺪأ اﻟﺤﺪث ‪ KeyUp‬ﺑﺎﻻﻧﻔﺠﺎر.‬
‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﺤﺪث ‪ KeyPress‬ﻓﻴﻔﺠﺮﻩ ‪ Visual Basic‬ﻓﻲ ﺣﺎﻟﺔ ﻗﻴﺎم اﻟﻤﺴـﺘﺨﺪم اﻟﻀـﻐﻂ‬
‫ﻋﻠـــــﻰ اﻟﻤﻔـــــﺎﺗﻴﺢ ]‪ [Ctrl+…] ،[ESCAPE] ،[BACKSPACE] ،[ENTER‬واﻟﺤـــــﺮوف‬
‫اﻟﻤﻄﺒﻮﻋﺔ، اﻣﺎ اﻟﻤﻔﺎﺗﻴﺢ اﻻﺧﺮى آﺎﻻﺳـﻬﻢ او ﻣﻔـﺎﺗﻴﺢ اﻟﻮﻇـﺎﺋﻒ وﻏﻴﺮهـﺎ... ﻓـﻼ ﺗـﺆدي‬
‫اﻟﻰ اﻧﻔﺠـﺎر اﻟﺤـﺪث ‪ KeyPress‬وﻟﻜـﻦ اﻻﺣـﺪاث ‪ KeyDown‬و ‪ KeyUp‬ﻟﻬـﺎ ﻧﺼـﻴﺐ ﻣـﻦ‬
‫اﻟﻮﻗﻮع. اﻟﻤﺰﻳﺪ اﻳﻀﺎ، ﻳﺮﺳﻞ اﻟﺤﺪث ‪ KeyPress‬ﻗﻴﻤﺔ ﻋﺪدﻳﺔ ﻣﻦ اﻟﻨﻮع ‪ Integer‬ﻣﺘﻤﺜﻠﺔ‬
‫ﻓﻲ ﻣﺘﻐﻴﺮ ﻋﺪدي ﺑﺎﻻﺳﻢ ‪ KeyAscii‬ﺗﻤﺜﻞ اﻟﻤﻘﺎﺑﻞ اﻟﻌﺪدي ﻟﻠﺤﺮف اﻟﻤﺪﺧﻞ ﻓﻲ ﺟﺪول‬
                                                                       ‫‪:ASCII‬‬

‫)‪Private Sub Form_KeyPress(KeyAscii As Integer‬‬
   ‫‪Print Chr$(KeyAscii) & " = " & KeyAscii‬‬
‫‪End Sub‬‬

‫اﻟﻤﺘﻐﻴﺮ ‪ KeyAscii‬ﻣﺮﺳﻞ ﺑﺎﻟﻤﺮﺟﻊ وﻟﻴﺲ اﻟﻘﻴﻤﺔ اي ﻳﻤﻜﻨﻚ ﺗﻌﺪﻳﻞ ﻗﻴﻤﺘﻪ ﻣﻤـﺎ ﻳﺘﺮﺗـﺐ‬
‫ﻋﻠﻴﻪ ﻣﺮوﻧﺔ آﺒﻴﺮ ﻓﻲ اﻟﺘﺤﻜﻢ ﻓﻲ ﻣﺪﺧﻼت اﻟﻤﺴﺘﺨﺪم، هﺬا اﻟﻜﻮد ﻣـﺜﻼ ﻳﺤـﻮل ﺟﻤﻴـﻊ‬
                        ‫اﻟﺤﺮوف اﻟﻤﺪﺧﻠﺔ ﻓﻲ أداة اﻟﻨﺺ اﻟﻰ ﺣﺮوف آﺒﻴﺮة ‪:Capital‬‬

‫)‪Private Sub Text1_KeyPress(KeyAscii As Integer‬‬
   ‫)))‪KeyAscii = Asc(UCase(Chr$(KeyAscii‬‬
‫‪End Sub‬‬

‫واذا اﺳﻨﺪت ﻗﻴﻤﺔ اﻟﺼـﻔﺮ اﻟـﻰ هـﺬا اﻟﻤﺘﻐﻴـﺮ، ﻓﺎﻧـﻚ ﻗـﺪ اﻟﻐﻴـﺖ ﻋﻤﻠﻴـﺔ ارﺳـﺎل ﻗﻴﻤـﺔ‬
‫اﻟﻤﻔﺘﺎح اﻟﻰ اﻷداة اﻟﻤﺴﺘﻘﺒﻠﺔ ﻟﻪ. هـﺬا اﻟﻜـﻮد ﻣـﺜﻼ ﻳﻤﻨـﻊ اﻟﻤﺴـﺘﺨﺪم ﻣـﻦ آﺘﺎﺑـﺔ أي‬
                                      ‫ﺷﺊ ﻓﻲ أدا اﻟﻨﺺ ﻋﺪا اﻻﻋﺪاد 0، 1، ...، 9:‬

‫)‪Private Sub Text1_KeyPress(KeyAscii As Integer‬‬
   ‫‪If KeyAscii < Asc("0") Or KeyAscii > Asc("9") Then‬‬
      ‫0 = ‪KeyAscii‬‬
   ‫‪End If‬‬
‫‪End Sub‬‬
                                               ‫63‬


 ‫ﺗﻼﺣﻆ اﻧﻨﻲ اﻋﺘﻤﺪ ﻓﻲ اﻻﻣﺜﻠﺔ اﻟﺴﺎﺑﻘﺔ ﻋﻠـﻰ اﻟـﺪاﻟﺘﻴﻦ ‪ Asc‬و $‪.Chr‬‬           ‫ﻣﻼﺣﻈﺔ:‬
 ‫ﻣﻊ ذﻟﻚ، ﻳﻤﻜﻨﻚ اﻻﺳـﺘﻐﻨﺎء ﻋﻨﻬﻤـﺎ اذا آﻨـﺖ ﺗﻌـﺮف اﻟﻤﻘﺎﺑـﻞ اﻟﻌـﺪدي‬
                                ‫ﻟﻠﺤﺮف اﻟﻤﻄﻠﻮب ﻓﻲ ﺟﺪول ‪.ASCII‬‬

‫ﻳــﺰودك اﻟﺤــﺪﺛﻴﻦ ‪ KeyDown‬و ‪ KeyUp‬ﺑﻘﻴﻤﺘــﻴﻦ اﻻوﻟــﻰ ‪ KeyCode‬وﺗﻤﺜــﻞ اﻟﻤﻔﺘــﺎح‬
‫اﻟﻤﺪﺧﻞ، واﻟﺜﺎﻧﻴﺔ هﻲ ‪ Shift‬وﺗﻤﺜﻞ ﺣﺎﻟـﺔ اﻟﻤﻔـﺎﺗﻴﺢ ]‪ [CTRL] ،[SHIFT‬و ]‪ [ALT‬ﻓﻴﻤـﺎ‬
                     ‫اذا آﺎﻧﺖ ﻣﻔﻌﻮﺻﺔ –اﻗﺼﺪ ﻣﻀﻐﻮﻃﺔ- او ﻻ آﻤﺎ ﻓﻲ اﻟﻜﻮد اﻟﺘﺎﻟﻲ:‬

‫)‪Private Sub Form_KeyDown(KeyCode As Integer, Shift As Integer‬‬
   ‫‪If Shift And vbShiftMask Then‬‬
      ‫اﻟﻤﻔﺘﺎح ]‪ [SHIFT‬ﻣﻀﻐﻮط '‬
   ‫‪End If‬‬
   ‫‪If Shift And vbCtrlMask Then‬‬
      ‫اﻟﻤﻔﺘﺎح ]‪ [CTRL‬ﻣﻀﻐﻮط '‬
   ‫‪End If‬‬
   ‫‪If Shift And vbAltMask Then‬‬
      ‫اﻟﻤﻔﺘﺎح ]‪ [ALT‬ﻣﻀﻐﻮط '‬
   ‫‪End If‬‬
‫‪End Sub‬‬

‫ﺑﺎﻟﻨﺴﺒﺔ اﻟﻰ ﻗﻴﻤﺔ اﻟﻤﻔﺘﺎح اﻟﻤﺪﺧﻞ -اﻟﻤﺘﻤﺜﻠﺔ ﻓﻲ اﻟﻤﺘﻐﻴـﺮ ‪ -KeyCode‬هـﻲ اﻟﻘﻴﻤـﺔ‬
‫اﻟﻔﻴﺰﻳﺎﺋﻴﺔ ﻟﻠﻤﻔﺘﺎح ﻓﻲ ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﻴﺢ، ﺻﺤﻴﺢ اﻧﻬـﺎ ﻣﺜـﻞ ﻗﻴﻤـﺔ اﻟﻤﺘﻐﻴـﺮ ‪ ،KeyAscii‬اﻻ‬
‫اﻧﻬﺎ ﻻ ﺗﻤﺜـﻞ ﻧﻮﻋﻴـﺔ اﻟﺤـﺮف اﻟﻤـﺪﺧﻞ ﺳـﻮاء آـﺎن ﺻـﻐﻴﺮ ‪ Small Letter‬او ﻋﻼﻣـﺎت آــ‬
‫؟%#@ .... اﻟﺦ، او ﺣﺘﻰ ﺣﺮوف ﻋﺮﺑﻴﺔ ا، ب، ت .... اﻟﺦ. ﻓﻬـﻲ ﺗﺮﺳـﻞ داﺋﻤـﺎ اﻟﻘﻴﻤـﺔ‬
‫ﻟﻠﺤﺮف اﻻﻧﺠﻠﻴﺰي اﻟﻜﺒﻴﺮ ‪ Capital‬آـ ‪ .... C ،B ،A‬اﻟـﺦ. اﻟﻤﺰﻳـﺪ اﻳﻀـﺎ، ﻻ ﻳﻤﻜﻨﻨـﺎ ﺗﻌـﺪﻳﻞ‬
‫ﻗﻴﻤﺔ اﻟﻤﻔﺘﺎح اﻟﻤﺪﺧﻞ ‪ KeyCode‬آﻤﺎ آﻨـﺎ ﻓﻌﻠﻨـﺎ ﻓـﻲ اﻟﺼـﻔﺤﺔ اﻟﺴـﺎﺑﻘﺔ ﻣـﻊ اﻟﻤﺘﻐﻴـﺮ‬
                                                                           ‫‪.KeyAscii‬‬
‫اﺧﻴﺮا، اﺣﺪاث ﻟﻮﺣـﺔ اﻟﻤﻔـﺎﺗﻴﺢ ‪ KeyDown ،KeyPress‬و ‪ KeyUp‬ﻳـﺘﻢ ﺗﻔﺠﻴﺮهـﺎ ﻋﻨـﺪﻣﺎ‬
‫ﻳﻜﻮن اﻟﺘﺮآﻴﺰ ﻋﻠﻰ اﻷداة اﻟﻤﻜﺘﻮب ﻓﻴﻬﺎ اﻟﻜﻮد، واذا وﺟﺪت اﺣﺪاث اﺿﺎﻓﻴﺔ ﺗﺎﺑﻌﺔ ﻟﻨﺎﻓـﺬة‬
‫اﻟﻨﻤﻮذج وﺳﺄﻟﺘﻨﻲ أي اﻻﺣﺪاث ﺳﻴﺘﻢ ﺗﻨﻔﻴﺬهﺎ اوﻻ؟، هﻞ هﻲ اﻻﺣﺪاث اﻟﺘﺎﺑﻌﺔ ﻟﻨﺎﻓﺬة‬
‫اﻟﻨﻤﻮذج ام اﻷداة اﻟﺘﻲ ﻋﻠﻴﻬﺎ اﻟﺘﺮآﻴﺰ؟ ﻓﺴـﺎﺧﺒﺮك ﺑـﺎن ﻟـﺪﻳﻚ ﻋﻘﻠﻴـﺔ ﻧﺒﻴﻬـﺔ ﺟـﺪا ﺟـﺪا‬
   ‫ـ‬
‫ﺗﺴــﺘﺤﻖ ان ﺗﻜــﻮن ﻣﺒــﺮﻣﺞ ‪ Visual Basic‬ﺑﺴــﺒﺒﻬﺎ! ﻓــﺎن آﺎﻧــﺖ ﻗﻴﻤــﺔ اﻟﺨﺎﺻــﻴﺔ‬
‫‪ KeyPreview‬اﻟﺘﺎﺑﻌﺔ ﻟﻨﺎﻓﺬة اﻟﻨﻤﻮذج ﺗﺴﺎوي ‪ ،True‬ﻓﺎن اﻟﻨﺎﻓﺬة ﺳـﺘﻔﺠﺮ اﺣـﺪاﺛﻬﺎ اوﻻ‬
‫وﻣﻦ ﺛﻢ اﻷداة اﻟﺘﻲ ﻋﻠﻴﻬﺎ اﻟﺘﺮآﻴﺰ، اﻣﺎ ان آﺎﻧﺖ ﻗﻴﻤﺔ هﺬﻩ اﻟﺨﺎﺻﻴﺔ ‪ ،False‬ﻓﺎن ﻧﺎﻓـﺬة‬
                                                  ‫73‬


‫اﻟﻨﻤﻮذج ﺳﺘﺘﺠﺎهﻞ هﺬﻩ اﻻﺣـﺪاث وآﺄﻧﻬـﺎ ﻏﻴـﺮ ﻣﻮﺟـﻮدة، وﻟـﻦ ﺗﻔﺠـﺮ اﻻ اﺣـﺪاث اﻷداة‬
                                                                       ‫ﻓﻘﻂ.‬

                                                         ‫ﺣﺪث اﻟﺘﻐﻴﻴﺮ ‪Change‬‬
‫ﻳﺘﻢ ﺗﻔﺠﻴﺮ ﺣﺪث اﻟﺘﻐﻴﻴﺮ ‪ Change‬ﺑﻤﺠـﺮد اﻟﻘﻴـﺎم ﺑﺘﻐﻴﻴـﺮ ﻣﺤﺘﻮﻳـﺎت اﻻداة آﺘﻐﻴـﺮ اﻟـﻨﺺ‬
‫اﻟﻈﺎهﺮ ﻓﻲ اﻟﺨﺎﺻﻴﺔ ‪ Caption‬او اﻟﺨﺎﺻﻴﺔ ‪ .Text‬وﻟﻜﻦ اﻻﻋﺘﻤﺎد ﻋﻠﻰ هﺬا اﻟﺤﺪث ﻓﻴﻪ‬
‫ﺷـــﻲء ﻣـــﻦ اﻟﺨﻄـــﺄ، ﻓﻌﻨـــﺪ ﺗﻐﻴﻴـــﺮ ﻗﻴﻤـــﺔ اﻟﺨﺎﺻـــﻴﺔ ‪ Value‬ﻟﻸداﺗـــﻴﻦ ‪ CheckBox‬و‬
‫‪ OptionButton‬ﻟﻦ ﻳﻘﻮم ‪ Visual Basic‬ﺑﺘﻔﺠﻴﺮ هﺬا اﻟﺤﺪث، آﺬﻟﻚ ﻋﻨـﺪ ﺗﻐﻴﻴـﺮ اﻟﺸـﻜﻞ‬
                     ‫اﻟﻈﺎهﺮي ﻟﻼدوات آﺤﺠﻤﻬﺎ او اﻟﻮاﻧﻬﺎ ﻟﻦ ﻳﺘﻢ ﺗﻔﺠﻴﺮ هﺬا اﻟﺤﺪث.‬


                                                                            ‫ﻧﺎﻓﺬة اﻟﻨﻤﻮذج‬
‫ﻧﺎﻓﺬة اﻟﻨﻤﻮذج ﻋﺰﻳﺰة ﻋﻠﻰ ﻗﻠـﻮب ﺟﻤﻴـﻊ ﻣﺒﺮﻣﺠـﻲ ‪ ،Visual Basic‬ﻓﻬـﻲ اﻟﺒـﺆرة اﻟﺘـﻲ‬
‫ﻧﺮى ‪ Visual Basic‬ﻣﻦ ﺧﻼﻟﻬﺎ ﻣﻊ اﻻﺳﻢ اﻻﺑﺘﺪاﺋﻲ ﻟﻬﺎ 1‪ Form‬واﻟـﺬي ﺻـﺎﺣﺒﻨﻲ ﻣﻨـﺬ‬
‫ﻋﺸﺮ ﺳﻨﻮات ﻣﻊ ﺑﺪاﻳﺎت 1‪ .VB‬وﻟﺤﺒﻲ ﻟﻬﺎ وﺗﻘـﺪﻳﺮي ﻟﻠﻌﺸـﺮة اﻟﻄﻮﻳﻠـﺔ ﺑﻴﻨـﻲ وﺑﻴﻨﻬـﺎ،‬
‫ﻗﺮرت ﺗﺨﺼﻴﺺ ﻓﻘﺮة ﺧﺎﺻﺔ ﺑﻬﺎ ﻓﻲ هـﺬا اﻟﻔﺼـﻞ وﻓﺼـﻞ آﺎﻣـﻞ "اﻻﺳـﺘﺨﺪام اﻟﻤﺘﻘـﺪم‬
‫ﻟﻠﻨﻤﺎذج" ﻓﻲ هﺬا اﻟﻜﺘﺎب، ﻋﺴﺎهﺎ ان ﺗﻤﻴﺰﻧﻲ ﺑﻴﻦ اﻟﻤﺒﺮﻣﺠﻴﻦ آﻤﺎ ﻣﻴﺰﺗﻬﺎ ﻋـﻦ ﺳـﺎﺋﺮ‬
                                                                       ‫اﻟﻜﺎﺋﻨﺎت!‬
‫ﻗﺒﻞ ان اﺧﻮض ﻓﻲ ﺗﻔﺼﻴﻞ ﻧﺎﻓﺬة اﻟﻨﻤﻮذج واﺗﺤـﺪث ﻋـﻦ ﺧﺼﺎﺋﺼـﻬﺎ، ﻃﺮﻗﻬـﺎ واﺣـﺪاﺛﻬﺎ،‬
‫ﺑﻮدي اﻟﺘﻄﺮق اﻟﻰ ﻓﻜـﺮة اﻟﻘﻮاﻟـﺐ ‪ Templates‬او ﻗﻮاﻟـﺐ اﻟﻨﻤـﺎذج ‪،Form Templates‬‬
‫وهﻲ ﻋﺒﺎرة ﻋﻦ ﻧﻤﺎذج ﺟﺎهﺰة اﻟﺘﺼﻤﻴﻢ وﻣﻀﺒﻮﻃﺔ اﻟﺨﺼﺎﺋﺺ ﺗﺴﺘﺨﺪﻣﻬﺎ ﻓﻲ ﺑﺮاﻣﺠﻚ‬
‫اﻟﻴﻮﻣﻴﺔ ﺑﺼﻮرة ﻣﺘﻜﺮرة دون اﻟﺤﺎﺟﺔ اﻟﻰ اﻋﺎدة ﺗﺼﻤﻴﻤﻬﺎ ﻣﻦ اﻟﺼـﻔﺮ. اﺧﺘـﺮ اﻻﻣـﺮ ‪Add‬‬
‫‪ Form‬ﻣﻦ ﻗﺎﺋﻤﺔ ‪ Project‬وﺳﺘﻔﻬﻢ اﻟﻔﻜﺮة ﻣﻦ ﻗﻮاﻟﺐ اﻟﻨﻤﺎذج اﻟﺠﺎهﺰة. ﻓﻔﻲ ﺻـﻨﺪوق‬
‫اﻟﺤﻮار اﻟﺬي ﺳﻴﻈﻬﺮ اﻣﺎﻣﻚ، ﺳﺘﺠﺪ اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﻨﻤﺎذج اﻟﺘـﻲ ﺗﺴـﺘﺨﺪﻣﻬﺎ آﺜﻴـﺮا ﻓـﻲ‬
‫ﺑﺮاﻣﺠﻚ اﻻﻋﺘﻴﺎدﻳﺔ، واذا آﺎﻧﺖ ﻻ ﺗﻤﻸ ﺑﺮﻳﻖ ﻋﻴﻨﻴﻚ، ﺻﻤﻢ ﻳﺎ ﻣﺼﻤﻢ اﻟﻨﻤﺎذج آﻤﺎ ﺗﺮﻳـﺪ،‬
‫وﻣﻦ ﺛﻢ ﻗﻢ ﺑﺤﻔﻈﻬﺎ ﻓﻲ اﻟﻤﺠﻠـﺪ ‪- \VB98\Template\Forms‬او اﻟﻤﺴـﺎراﻟﻤﺤﺪد ﻓـﻲ‬
‫ﺧﺎﻧﺔ اﻟﺘﺒﻮﻳﺐ ‪ Environment‬ﻓـﻲ ﺻـﻨﺪوق اﻟﺤـﻮار ‪ -Options‬ﺳـﺘﻼﺣﻆ وﺟـﻮد ﻧﺎﻓـﺬﺗﻚ‬
                                           ‫آﻘﺎﻟﺐ ‪ Template‬ﺑﻴﻦ اﻟﻘﻮاﻟﺐ اﻟﺴﺎﺑﻘﺔ.‬

                                                               ‫ﺧﺼﺎﺋﺺ اﻟﻨﻤﻮذج‬
‫ﺑﻌــﺪ ان ﺗﺒــﺮق ﻧﺎﻓــﺬة اﻟﻨﻤــﻮذج اﻣــﺎم ﻋﻴﻨﻴــﻚ، ﺳــﺘﺒﺪأ ﺑﻮﺿــﻊ اﻻدوات ﻋﻠﻴﻬــﺎ وﻣــﻦ ﺛــﻢ‬
‫ﺗﺤﺠﻴﻤﻬﺎ. وﺑﻌﺪ ذﻟﻚ، ﺗﻘﻮم ﺑﺎﺧﺘﻴﺎر ﺷﻜﻞ ﺣﺪودهﺎ ﻣﻊ اﻟﺨﺎﺻـﻴﺔ ‪ .BorderStyle‬اﻟﻘﻴﻤـﺔ‬
‫‪ 0-None‬ﻻ اﺳﺘﺨﺪﻣﻬﺎ اﻻ ﻓﻲ اﻟﺸﺎﺷـﺔ اﻻﻓﺘﺘﺎﺣﻴـﺔ ‪ Splash Screen‬ﻟﺒﺮاﻣﺠـﻲ ﻻﻧﻬـﺎ‬
                                               ‫83‬


‫ﺗﺨﻔﻲ ﺣـﺪودهﺎ وﺣﺘـﻰ ﺷـﺮﻳﻂ ﻋﻨﻮاﻧﻬـﺎ ‪ ،TitleBar‬ﻓﺘﻤﻨـﻊ اﻟﻤﺴـﺘﺨﺪم ﻣـﻦ اﻣﻜﺎﻧﻴـﺎت‬
‫ﺗﺤﺮﻳﻚ اﻟﻨﺎﻓﺬة وﺗﺴﺒﺐ ﻟﻪ ﺣﺎﻟﺔ ﻣﻦ اﻟﻨﺪم ﻋﻠﻰ ﺗﺸﻐﻴﻞ ﺑﺮﻧﺎﻣﺠﻚ ان ﻟﻢ ﻳﻘـﻢ ﺑﺎﻟﻀـﻐﻂ‬
            ‫ـ‬         ‫ـ‬                                                 ‫ـ‬
‫ﻋﻠـ ـﻰ اﻟﻤﻔـ ـﺎﺗﻴﺢ ]‪ [Ctrl+Alt+Del‬او ]‪ [Ctrl+Shift+Esc‬آـــﻲ ﻳـ ـﺘﻤﻜﻦ ﻣـ ـﻦ اﻏـــﻼق‬ ‫ـ‬
‫ﺑﺮﻧﺎﻣﺠﻚ. اﻣﺎ اﻟﻘﻴﻤﺔ ‪ 2-Sizable‬ﻓﺴﺘﻤﻜﻦ اﻟﻤﺴﺘﺨﺪم ﻣﻦ ﺗﺤﺮﻳـﻚ اﻟﻨﺎﻓـﺬة ﺑﺎﻧﺴـﻴﺎﺑﻴﺔ‬
‫ﻣﺮﻳﺤﺔ وﺗﻤﻜﻨﻪ اﻳﻀﺎ ﻣﻦ اﻋﺎدة ﺗﺤﺠﻴﻢ اﻟﻨﺎﻓﺬة ﺑﺎﻟﺸﻜﻞ اﻟـﺬي ﻳﻨﺎﺳـﺒﻪ وﻟـﻦ ﻳﻘـﻮم –ان‬
‫ﺷﺎء اﷲ- ﺑﺎﺳﺘﺨﺪام اﻟﻤﻔﺎﺗﻴﺢ اﻟﺴﺎﺑﻘﺔ. اﻟﻘﻴﻤﺘـﺎن ‪ 1-Fixed Single‬و ‪3-Fixed Dailog‬‬
‫ﺗﻤﻨﻊ اﻟﻤﺴﺘﺨﺪم ﻣﻦ اﻋﺎدة ﺗﺤﺠﻴﻢ اﻟﻨﺎﻓﺬة ﻣﻊ اﺑﻘﺎء ﺷﺮﻳﻂ اﻟﻌﻨﻮان وهﻲ ﻗﻴﻢ ﻗﻴﺎﺳﻴﺔ‬
‫ﻟﺼﻨﺎدﻳﻖ ﺣﻮار ‪ Dialog Boxes‬ﺗﻄﺒﻴﻘﺎت ‪ ،Windows‬واﻟﻔﺮق ﺑﻴﻦ اﻟﻘﻴﻤﺘﻴﻦ ﻳﻈﻬـﺮ ﺟﻠﻴـﺎ‬
‫ﻓﻲ ان اﻻوﻟﻰ ﺗﺴﻤﺢ ﺑﻈﻬﻮر زر اﻟﺘﻜﺒﻴﺮ ‪ Maximize‬واﻟﺘﺼـﻐﻴﺮ ‪ Minimize‬ﻋﻠـﻰ ﺷـﺮﻳﻂ‬
                                           ‫ـ‬               ‫ـ‬      ‫ـ ـ‬       ‫ـ‬
‫اﻟﻌﻨ ـﻮان اﻣ ـﺎ اﻟﺜﺎﻧﻴ ـﺔ ﻓ ـﻼ. اﺳ ـﺘﺨﺪم اﻟﻘﻴﻤﺘ ـﻴﻦ ‪ 4-Fixed ToolWindow‬و ‪5-Sizable‬‬‫ـ‬
              ‫ـ‬     ‫ـ‬       ‫ـ‬
‫‪ ToolWindow‬ﻟﺘﺼـﻐﻴﺮ ارﺗﻔـﺎع ﺷـﺮﻳﻂ اﻟﻌﻨـﻮان وهـﻲ ﻣﻮﺿـﺔ ﻟﻨﻮاﻓـﺬ اﺷـﺮﻃﺔ اﻻدوات.‬
                                    ‫ـ‬       ‫ـ‬       ‫ـ‬        ‫ـ‬      ‫ـ‬
‫ﺗﻮﺟﺪ ﻗﻴﻤﺔ ﺳﺎدﺳﺔ ﻟﺸﻜﻞ اﻟﺤﺪ اﺷـﺒﻪ ﻣـﺎ ﺗﻜـﻮن ﺑﺎﻟﻘﻴﻤـﺔ ‪ 0-None‬ﻟﻜـﻦ ﻣـﻊ ﺣـﺪود‬
    ‫ـ‬     ‫ـ‬       ‫ـ‬         ‫ـ‬
‫ﺛﻼﺛﻴ ـﺔ اﻻﺑﻌ ـﺎد ‪ ،3-D‬وﻟ ـﻦ ﺗﺴ ـﺘﻄﻴﻊ ﻣﺸ ـﺎهﺪﺗﻬﺎ اﻻ ان آﺎﻧ ـﺖ اﻟﻘﻴﻤ ـﺔ اﻟﻤﻮﺟ ـﻮدة ﻓ ـﻲ‬
                                              ‫ـ‬          ‫ـ‬      ‫ـ‬         ‫ـ‬     ‫ـ‬
  ‫ـ‬       ‫ـ‬             ‫ـ‬                     ‫ـ‬       ‫ـ‬        ‫ـ‬
‫اﻟﺨﺎﺻـﻴﺔ ‪ Caption‬ﺧﺎﻟﻴـﺔ، وﻗﻴﻤـﺔ اﻟﺨﺎﺻـﻴﺔ ‪ ControlBox‬ﺗﺴـﺎوي ‪ ،False‬ﻣـﻊ اﺧﺘﻴ ـﺎر‬‫ـ‬
                          ‫اﻟﻘﻴﻤﺔ ‪ 3-Fixed Dailog‬ﻣﻦ اﻟﺨﺎﺻﻴﺔ اﻟﺴﺎﺑﻘﺔ ‪.BorderStyle‬‬
‫ﺗﺴﺘﻄﻴﻊ اﻇﻬﺎر، اﺧﻔﺎء او ﺗﻤﻜﻴﻦ ﺻﻨﺪوق اﻟﺘﺤﻜﻢ او ازرار اﻟﺘﻜﺒﻴﺮ واﻟﺘﺼـﻐﻴﺮ ﻋـﻦ ﻃﺮﻳـﻖ‬
‫اﻟﺨﺼﺎﺋﺺ ‪ MaxButtom ،ControlBox‬و ‪ .MinButton‬اﻟﻨﺺ اﻟﺬي ﺳﻴﻈﻬﺮ ﻓﻲ ﺷـﺮﻳﻂ‬
‫ﻋﻨﻮان اﻟﻨﺎﻓـﺬة هـﻮ ﻧﻔـﺲ اﻟـﻨﺺ اﻟﻤﻮﺟـﻮد ﻓـﻲ اﻟﺨﺎﺻـﻴﺔ ‪ .Caption‬ﺗﺴـﺘﻄﻴﻊ ﺗﻮﺳـﻴﻂ‬
‫اﻟﻨﺎﻓــﺬة وﺳــﻂ اﻟﺸﺎﺷــﺔ ﻋــﻦ ﻃﺮﻳــﻖ اﺧﺘﻴــﺎر اﻟﻘﻴﻤــﺔ ‪ 2-Center‬ﻣــﻦ ﻗــﻴﻢ اﻟﺨﺎﺻــﻴﺔ‬
‫‪ ،StartupPosition‬وﺑﺎﻣﻜﺎﻧﻚ ﻣﻨﻊ اﻟﻤﺴﺘﺨﺪم ﻣـﻦ ﺗﺤﺮﻳـﻚ اﻟﻨﺎﻓـﺬة ﻋـﻦ ﻃﺮﻳـﻖ ﺗﺤﻮﻳـﻞ‬
‫ﻗﻴﻤﺔ اﻟﺨﺎﺻﻴﺔ ‪ Moveable‬اﻟﻰ ‪ .False‬اﻣﺎ اﻟﺨﺎﺻﻴﺔ ‪ ShowInTaskBar‬ﻓﻬﻲ ﺗﻀـﻴﻒ زر‬
       ‫ـ‬                     ‫ـ‬                                        ‫ـ‬
‫اﻟـﻰ ﺷـﺮﻳﻂ اﻟﻤﻬـﺎم ‪ Windows Task Bar‬ﺑﺠﺎﻧـﺐ زر "اﺑـﺪأ" او ‪ Start‬ﺑﺤﻴـﺚ ﻳـﺘﻤﻜﻦ‬
‫اﻟﻤﺴﺘﺨﺪم ﻣﻦ ﺗﻨﺸﻴﻂ ﻧﺎﻓﺬة ﺑﺮﻧﺎﻣﺠﻚ ﺑﻤﺠﺮد اﻟﻨﻘـﺮ ﻋﻠـﻰ هـﺬا اﻟـﺰر. اﺧﻴـﺮا، ﺧﺎﺻـﻴﺔ‬
‫‪ WindowState‬اﻟﺘﻲ ﺗﻤﻜﻨﻚ ﻣﻦ ﺗﻜﺒﻴﺮ اﻟﻨﺎﻓـﺬة ﻟﺘﻐﻄـﻲ آﺎﻣـﻞ اﻟﺸﺎﺷـﺔ، ﺗﺼـﻐﻴﺮهﺎ او‬
                                                        ‫اﺳﺘﺮﺟﺎع اﻟﺤﺠﻢ اﻟﻄﺒﻴﻌﻲ ﻟﻬﺎ.‬

                                                              ‫ﺧﺼﺎﺋﺺ اﻟﺼﻮر:‬
‫ﻋﻦ ﻃﺮﻳﻖ اﻟﺨﺎﺻﻴﺔ ‪ AutoRedraw‬ﺗﺤﺪد ﻣﺎ اذا آﺎﻧﺖ اﻋﺎدة رﺳﻢ ﻧﺎﻓـﺬة اﻟﻨﻤـﻮذج ﺗـﺘﻢ‬
‫ﺗﻠﻘﺎﺋﻴﺎ ‪ True‬او ﻳﺪوﻳﺎ ‪ False‬ﺑﻮاﺳﻄﺔ اآﻮادك. ﻓـﻲ اﻟﺤﺎﻟـﺔ اﻻوﻟـﻰ ﻓـﺎن ﺳـﺮﻋﺔ اﻋـﺎدة‬
‫اﻟﺮﺳﻢ ﺗﻜﻮن اﺳﺮع ﻣﻦ اﻟﺤﺎﻟﺔ اﻟﺜﺎﻧﻴﺔ، اﻻ اﻧﻬﺎ ﺗﺴﺘﻬﻠﻚ اﻻف اﻟﻜﻴﻠﻮﺑﺎﻳﺘﺎت ﻓﻲ اﻟﺬاآﺮة‬
‫ﻣﻤﺎ ﻳﻘﻠﻞ ﻣﻦ ﻣﺼﺎدر اﻟﻨﻈـﺎم ‪ System Resources‬اﻟﻤﺘﺎﺣـﺔ ﻟﻠﺒـﺮاﻣﺞ اﻻﺧـﺮى، ﻟـﻚ ان‬
  ‫ﺗﺘﺨﻴــﻞ ﻧﺎﻓــﺬة ﺣﺠﻤﻬــﺎ 006‪ 800x‬ﻣــﻊ ﻋﻤــﻖ ﻟــﻮﻧﻲ ‪ True Color‬ﺗﺴــﺘﻬﻠﻚ 6041‬
‫آﻴﻠﻮﺑﺎﻳﺖ –ﻣﺎ ﻳﺰﻳﺪ ﻋﻠﻰ 1ﻣﻴﺠـﺎ، وﻟـﻚ ان ﺗﺘﺨﻴـﻞ 5 او 9 ﻧﻮاﻓـﺬ ﺟﺸـﻌﺔ ﻣـﻦ ﺑﺮﻧﺎﻣﺠـﻚ‬
‫ﻣﻔﺘﻮﺣﺔ، وآﻢ ﺳﺘﺴﺒﺐ ﻣـﻦ اﻟـﺒﻂء ﻓـﻲ اﻟﺘﺤﻤﻴـﻞ واﻟﺤﺠـﺰ اﻟﻜﺒﻴـﺮ ﻓـﻲ اﻟـﺬاآﺮة؟ ﻣـﻦ‬
                                                 ‫93‬


‫اﻟﻤﻬﻢ ان اذآﺮ هﻨﺎ ﺑﺎن اﻟﺤﺪث ‪ Form_Paint‬ﻟﻦ ﻳﺘﻢ ﺗﻔﺠﻴـﺮﻩ اﺑـﺪا ﻃﺎﻟﻤـﺎ آﺎﻧـﺖ ﻗﻴﻤـﺔ‬
‫هﺬﻩ اﻟﺨﺎﺻﻴﺔ ‪ .True‬ﺑﺎﺧﺘﺼـﺎر، ﻻ ﺗﺴـﺘﺨﺪم هـﺬﻩ اﻟﺨﺎﺻـﻴﺔ اﻻ ﻋﻨـﺪ اﻟﺤﺎﺟـﺔ اﻟﻤﺎﺳـﺔ‬
‫ﻓﻘﻂ، وﺣﺎول وﺿﻊ اآﻮاد اﻟﻜﺘﺎﺑﺔ واﻟﺮﺳﻢ آــ ‪ .... Line ،Print‬اﻟـﺦ ﺑـﻴﻦ ﺳـﻄﻮر اﻟﺤـﺪث‬
                                                                             ‫‪.Form_Paint‬‬
‫اذا آﻨﺖ ﺗﺴﺘﺨﺪم ﻃﺮق اﻟﺮﺳـﻢ ‪ .... Circle ،Line‬اﻟـﺦ ﺑﻜﺜـﺮة، ﻓﺎﻧﺼـﺤﻚ ﺑﺘﻐﻴﻴـﺮ ﻗﻴﻤـﺔ‬
‫اﻟﺨﺎﺻﻴﺔ ‪ ClipControls‬اﻟﻰ ‪ False‬ﺣﺘﻰ ﺗﺰﻳﺪ ﺳﺮﻋﺔ ﻃﺮق اﻟﺮﺳﻢ ﺑﻤﻘﺪار اﻟﻀﻌﻒ ﻻن‬
‫‪ Visual Basic‬ﻟﻦ ﻳﻘﻮم ﺑﺈﻧﺸﺎء ﻣﻨﻄﻘﺔ ‪ Clipping region‬وﻟﻦ ﻳﻘﻮم ﺑﺎﻋـﺎدة اﻟﺮﺳـﻢ اﻻ‬
‫ﻟﻠﻤﻨﺎﻃﻖ اﻟﺘﻲ ﺗﺤﺘﺎج اﻟﻰ اﻋﺎدة رﺳﻢ، اﻣﺎ اذا ﻟـﻢ ﺗﺴـﺘﺨﺪم ﻃـﺮق اﻟﺮﺳـﻢ، ﻓﺎﻟﻘﻴﻤـﺔ‬
                                                        ‫‪ True‬ﺗﻜﻮن ﻣﻨﺎﺳﺒﺔ ﻟﻬﺬﻩ اﻟﺨﺎﺻﻴﺔ.‬
‫اﻟﺨﺎﺻﻴﺔ ‪ HasDC‬ﺗﺨﻴـﺮك ﻓﻴﻤـﺎ ﻟـﻮ آﻨـﺖ ﺗﺮﻳـﺪ إﻧﺸـﺎء ﺳـﻴﺎق رﺳـﻢ ‪Device Context‬‬
‫ﻟﻨﺎﻓﺬة اﻟﻨﻤﻮذج ام ﻻ، ﺳﻴﺎق اﻟﺮﺳﻢ ﻋﺒﺎرة ﻋﻦ ﺗﺮآﻴﺐ ﺧﺎص ﺑﻨﻈـﺎم اﻟﺘﺸـﻐﻴﻞ ﻳﺤﻤـﻞ‬
‫ﻣﻮاﺻﻔﺎت وﺑﻴﺎﻧﺎت اﻟﺼﻮرة. اذا آﻨﺖ ﻻ ﺗﻨﻮي وﺿﻊ ﺻﻮرة ﻓﻲ اﻟﺨﺎﺻﻴﺔ ‪ ،Picture‬ﻓﺎﺟﻌـﻞ‬
      ‫ـ‬      ‫ـ‬     ‫ـ‬         ‫ـ‬           ‫ـ‬
‫ﻗﻴﻤـﺔ ه ـﺬﻩ اﻟﺨﺎﺻ ـﻴﺔ ‪ False‬آـﻲ ﺗﻘﻠ ـﻞ ﻣ ـﻦ اﺳ ـﺘﻬﻼك ﻣﺼـﺎدر اﻟﻨﻈ ـﺎم ﻣ ـﻊ اﻟﻌﻠ ـﻢ ان‬
                                                 ‫ـ‬    ‫ـ‬     ‫ـ‬           ‫ـ‬        ‫ـ‬   ‫ـ‬
‫اﻟﺨﺎﺻــﻴﺔ ‪ hDC‬ﻟــﻦ ﺗﻌﻤــﻞ ﻣﻌــﻚ اﻻ اذا ﻗﻤــﺖ ﺑﺘﺤﻤﻴــﻞ ﺻــﻮرة ﻋﻠــﻰ ﻧﺎﻓــﺬة اﻟﻨﻤــﻮذج‬
                   ‫ﻓﺴﺘﺤﻤﻞ اﻟﺨﺎﺻﻴﺔ ‪ hDC‬ﻗﻴﻤﺔ ﻣﺆﻗﺘﺔ ﺗﺰول ﻣﺒﺎﺷﺮة ﺑﻌﺪ زوال اﻟﺼﻮرة.‬
‫اﻟﺨﺎﺻﻴﺔ ‪ Icon‬ﺗﻤﺜﻞ اﻟﺮﻣﺰ اﻟﺬي ﻳﻈﻬﺮ ﻓﻲ ﺻﻨﺪوق اﻟﺘﺤﻜﻢ ‪ Control Box‬اﻟﺘﺎﺑﻊ ﻟﻨﺎﻓﺬة‬
‫اﻟﻨﻤﻮذج واﻟﺮﻣﺰ اﻟﻈﺎهﺮ ﻋﻠﻰ زر اﻟﻨﺎﻓﺬة ﻓﻲ ﺷـﺮﻳﻂ اﻟﻤﻬـﺎم ، هـﺬا إذا آﺎﻧـﺖ اﻟﺨﺎﺻـﻴﺔ‬
‫‪ ShowInTaskbar‬ﺗﺴــﺎوي ‪ ،True‬اﻣــﺎ ان آﺎﻧــﺖ ﻗﻴﻤــﺔ اﻟﺨﺎﺻــﻴﺔ )‪ (None‬ﻓــﺎن ﻧﻈــﺎم‬
‫اﻟﺘﺸﻐﻴﻞ ﻳﻀﻊ رﻣﺰ اﻓﺘﺮاﺿﻲ ﺷـﺮﻳﻄﺔ أن ﺗﻜـﻮن ﻗﻴﻤـﺔ اﻟﺨﺎﺻـﻴﺔ ‪ ControlBox‬ﺗﺴـﺎوي‬
‫‪ .True‬ﻣـﻦ اﻟﻀـﺮوري أن ﺗﻌﻠـﻢ اﻧـﻪ ﻻ ﻳﻤﻜﻨـﻚ ﺗﺨﺼـﻴﺺ رﻣـﺰ اﻟﺒﺮﻧـﺎﻣﺞ ‪EXE File Icon‬‬
‫ﺑﺸــﻜﻞ ﻣﺴــﺘﻘﻞ، ﻓـــ ‪ Visual Basic‬ﻳﺨﻴــﺮك ﺑــﻴﻦ اﺣــﺪ رﻣــﻮز ﻧﻮاﻓــﺬ اﻟﻨﻤــﺎذج اﻟﺘﺎﺑﻌــﺔ‬
‫ﻟﻤﺸﺮوﻋﻚ ﻋﻦ ﻃﺮﻳﻖ اﻟﻘﺎﺋﻤﺔ ‪ Icon‬ﻣﻦ ﺧﺎﻧﺔ اﻟﺘﺒﻮﻳﺐ ‪ Make‬اﻟﻤﻮﺟـﻮدة ﻓـﻲ ﺻـﻨﺪوق‬
                                              ‫ﺣﻮار ﺧﺼﺎﺋﺺ اﻟﻤﺸﺮوع ‪.Project Properties‬‬
‫اﻟﺨﺎﺻﻴﺔ ‪ Picture‬ﺗﻤﻜﻨﻚ ﻣﻦ ﺗﺤﻤﻴﻞ ﻣﻠﻒ ﺻـﻮرة ووﺿـﻌﻪ ﻓـﻲ داﺧـﻞ ﻧﺎﻓـﺬة اﻟﻨﻤـﻮذج،‬
‫ﺗــﺪﻋﻢ هــﺬﻩ اﻟﺨﺎﺻــﻴﺔ هﻴﺌــﺎت ﻣﺨﺘﻠﻔــﺔ ﻣــﻦ اﻟﻤﻠﻔــﺎت هــﻲ: ‪،JPG ،GIF ،DIB ،BMP‬‬
‫‪ ICO ،EMF ،WMF‬و ‪ .CUR‬ﺗﺴﺘﻄﻴﻊ ﺗﺤﻤﻴﻞ ﻣﻠﻒ اﻟﺼﻮرة وﻗﺖ اﻟﺘﺼﻤﻴﻢ ﺑﺎﺧﺘﻴﺎر اﺳـﻢ‬
‫اﻟﻤﻠﻒ ﻣﻦ ﺻﻨﺪوق ﺣـﻮار اﻟﺨﺎﺻـﻴﺔ، او اﺳـﺘﺨﺪام ﻃﺮﻳﻘـﺔ اﺧـﺮى اﻓﻀـﻠﻬﺎ آﺜﻴـﺮا وهـﻲ‬
‫ﻧﺴﺦ ‪ Copy‬اﻟﺼﻮرة ﻣـﻦ اﻟﺒﺮﻧـﺎﻣﺞ اﻟـﺬي ﻳﻌﺮﺿـﻬﺎ اﻟـﻰ اﻟﺤﺎﻓﻈـﺔ ‪ Clipboard‬وﻣـﻦ ﺛـﻢ‬
‫ﻟﺼﻘﻬﺎ ﺑﺎﺧﺘﻴﺎر اﻻﻣﺮ ‪ Paste‬ﻣﻦ اﻟﻘﺎﺋﻤﺔ ‪ .Edit‬واذا اردت وﺿﻊ اﻟﺼﻮرة ﻓﻲ وﻗﺖ اﻟﺘﻨﻔﻴﺬ،‬
            ‫ﻓﺎﻟﺪاﻟﺔ ‪ LoadPicture‬ﺗﻤﻜﻨﻚ ﻣﻦ ﻓﻌﻞ ذﻟﻚ او ﺳﺮﻗﺔ ﺻﻮرة ﺗﺎﺑﻌﺔ ﻟﻜﺎﺋﻦ ﺁﺧﺮ:‬

‫ﺗﺤﻤﻴﻞ ﺻﻮرة وﺟﻬﻲ اﻟﻮﺳﻴﻢ! ‘ )”‪Form1.Picture = LoadPicture (“C:\Turki.BMP‬‬
‫ﻧﻔﺲ اﻟﺼﻮرة اﻟﻤﻮﺟﻮدة ﻓﻲ اﻟﻨﻤﻮذج 1‪Form2.Picture = Form1.Picture ‘ Form‬‬
                                              ‫04‬


 ‫اﻟﺨﺎﺻﻴﺔ ‪ Picture‬هﻲ آـﺎﺋﻦ ﻳﺤﺘـﻮي ﻋﻠـﻰ ﺧﺼـﺎﺋﺺ اﺿـﺎﻓﻴﺔ آﻌـﺮض‬             ‫ﻣﻼﺣﻈﺔ:‬
                                       ‫اﻟﺼﻮرة وارﺗﻔﺎع وﻏﻴﺮهﺎ:‬
 ‫‪Print Me.Picture.Height‬‬
 ‫‪Print Me.Picture.Width‬‬

‫اﺿﺎف 6‪ VB‬ﻣﺘﻐﻴﺮات ﺟﺪﻳﺪة اﻟﻰ اﻟﺪاﻟﺔ ‪ LoadPicture‬ﺗﻤﻜﻨﻚ ﻣﻦ اﺳﺘﺨﻼص رﻣﺰ ‪Icon‬‬
‫ﻣﻦ ﻣﺠﻤﻮﻋﺔ رﻣﻮز ﻣﻀﻤﻨﺔ ﻓﻲ ﻣﻠﻒ ‪ ICO‬ﺗﺠﺪ ﺷـﺮح واﻓـﻲ ﻟﻬـﺎ ﻓـﻲ ﻣﻜﺘﺒـﺔ ‪،MSDN‬‬
‫وﺑﻤﺎ اﻧﻨﻲ ذآﺮت اﻟﺪاﻟﺔ ‪ ،LoadPicture‬ﻓﻤﺎ اﻟﻤﺎﻧﻊ ﻣﻦ ذآﺮ زﻣﻴﻠﺘﻬﺎ ‪ SavePicture‬اﻟﺘـﻲ‬
                                              ‫ﺗﻤﻜﻨﻚ ﻣﻦ ﺣﻔﻆ اﻟﺼﻮرة اﻟﻰ ﻣﻠﻒ:‬

‫”‪SavePicture Form1.Picture, “C:\Aseeri.BMP‬‬

 ‫اﻟﻬﻴﺌﺔ ‪ Format‬اﻟﺘﻲ ﺗﺤﻔﻆ ﺑﻬﺎ اﻟﺪاﻟﺔ ‪ SavePicture‬هﻲ ﻧﻔﺲ هﻴﺌـﺔ‬           ‫ﻣﻼﺣﻈﺔ:‬
 ‫اﻟﺼﻮرة اﻟﺘﻲ ﺣﻤﻠﺖ ﻓﻲ اﻟﺨﺎﺻﻴﺔ، ﺑﺎﺳﺘﺜﻨﺎء اﻟﻬﻴﺌﺎت ‪ GIF‬و ‪ JPG‬ﻓﻴﺘﻢ‬
                                       ‫ﺗﺤﻮﻳﻠﻬﻤﺎ اﻟﻰ اﻟﻬﻴﺌﺔ ‪.BMP‬‬

                                                              ‫ﺧﺼﺎﺋﺺ اﻟﺮﺳﻢ:‬
‫اﻟﺨﺎﺻﻴﺔ ‪ Image‬ﺗﻤﺜﻞ اﻟﺮﺳﻤﺔ اﻟﻤﻮﺟﻮدة ﻋﻠﻰ ﻧﺎﻓﺬة اﻟﻨﻤﻮذج اﻟﻨﺎﺗﺠﺔ ﻣـﻦ اﺳـﺘﺨﺪام‬
‫ﻃﺮق اﻟﺮﺳﻢ ‪ .... Cirle ،Line‬اﻟﺦ، وﺳﺘﻜﻮن داﺋﻤﺎ ﻓﻮق اﻟﺼﻮرة اﻟﻤﻮﺟﻮدة ﻓﻲ اﻟﺨﺎﺻﻴﺔ‬
‫‪ ،Picture‬ﻟﻦ ﺗﺴﺘﻄﻴﻊ اﺳﺘﺨﺪام او اﻻﺳﺘﻔﺎدة –ان ﺻﺢ اﻟﺘﻌﺒﻴﺮ- ﻣﻦ هـﺬﻩ اﻟﺨﺎﺻـﻴﺔ اﻻ‬
                                  ‫ان آﺎﻧﺖ ﻗﻴﻤﺔ اﻟﺨﺎﺻﻴﺔ ‪ AutoRedraw‬هﻲ ‪.True‬‬
‫اﻟﺨﺎﺻﻴﺔ ‪ DrawWidth‬ﺗﺤﺪد ﻋﺮض او ﺳـﻤﻚ اﻟﻔﺮﺷـﺎة اﻟﻤﺴـﺘﺨﺪﻣﺔ ﻟﺮﺳـﻢ اﻟﺨﻄـﻮط‬
‫واﻻﺷﻜﺎل ﺑﻄـﺮق اﻟﺮﺳـﻢ ‪ Line ،PSet‬و ‪ Circle‬اﻣـﺎ اﻟﺨﺎﺻـﻴﺔ ‪ ForeColor‬ﻓﻬـﻲ ﺗﺤـﺪد‬
‫اﻟﻠﻮن اﻻﻓﺘﺮاﺿﻲ ﻟﻠﻄﺮق اﻟﺴﺎﺑﻘﺔ. ﺑﺎﻟﻨﺴـﺒﺔ ﻟﻠﺨﺎﺻـﻴﺔ ‪ DrawStyle‬ﻓﻬـﻲ ﺗﻤﻜﻨـﻚ ﻣـﻦ‬
‫ﺗﺤﺪﻳﺪ ﺷﻜﻞ اﻟـﻨﻘﺶ ﻟﺮﺳـﻢ اﻟﺨﻄـﻮط واﻟـﺪواﺋﺮ ﺑﺎﺳـﺘﺨﺪام اﻟﻄـﺮﻳﻘﺘﻴﻦ ‪ Line‬و ‪،Cirlce‬‬
‫آﺬﻟﻚ ﺗﻤﻜﻨﻚ ﻣﻨﻪ اﻟﺨﺎﺻﻴﺔ ‪ FillStyle‬ﻟﻠﻤﻨﻄﻘﺔ اﻟﺪاﺧﻠﻴﺔ ﻣﻦ اﻟﻤﺮﺑﻊ او اﻟﺪاﺋﺮة ﻣـﻊ ﻟـﻮن‬
‫اﻟﺘﻌﺒﺌــﺔ اﻟﻤﻮﺟــﻮد ﻓــﻲ اﻟﺨﺎﺻــﻴﺔ ‪ .FillColor‬اﻣــﺎ اﻟﺨﺎﺻــﻴﺘﺎن ‪ CurrentX‬و ‪CurrentY‬‬
‫ﻓﺘﻤﺜﻼن اﻻﺣﺪاﺛﻴﺎت اﻟﺤﺎﻟﻴﺔ اﻟﺘـﻲ ﺗﺴـﺘﺨﺪم ﻟﻄـﺮق اﻟﻤﺨﺮﺟـﺎت واﻟﺮﺳـﻢ ‪Line ،Print‬‬
‫.... اﻟﺦ، واﻟﻠﺘﺎن ﺗﺘﺄﺛﺮان ﺑﻜﻞ ﻋﻤﻠﻴـﺔ رﺳـﻢ او ﺧـﺮج ﺑﺎﺳـﺘﺨﺪام اﻟﻄـﺮق اﻟﺴـﺎﺑﻘﺔ. اﻣـﺎ‬
‫اﻟﺨﺎﺻﻴﺔ ‪ FontTransparent‬ﻓﻬﻲ ﺗﺤﺪد اﺳﻠﻮب ﺧﺮج اﻟﻄﺒﺎﻋﺔ ﺑﺎﺳﺘﺨﺪام اﻻﻣﺮ ‪،Print‬‬
‫ﻓﺈن آﺎﻧﺖ ﻗﻴﻤﺔ اﻟﺨﺎﺻﻴﺔ ﺗﺴﺎوي ‪ False‬ﻓﺴﻴﻜﻮن ﻟﻮن ﺧﻠﻔﻴﺔ اﻟﻄﺒﺎﻋﺔ هﻮ ﻧﻔـﺲ ﻟـﻮن‬
‫اﻟﺨﻠﻔﻴﺔ ‪ BackColor‬ﻟﻠﻨﻤﻮذج، أﻣﺎ إن آﺎﻧﺖ ﻗﻴﻤﺔ اﻟﺨﺎﺻﻴﺔ ‪ True‬ﻓـﺈن ﺧﻠﻔﻴـﺔ اﻟﻄﺒﺎﻋـﺔ‬
                                                                  ‫ﺳﺘﻜﻮن ﺷﻔﺎﻓﺔ.‬
                                           ‫14‬


                                                       ‫اﻟﺨﺎﺻﻴﺔ ‪:DrawMode‬‬
‫ﺗﻌﺘﺒﺮ اﻟﺨﺎﺻﻴﺔ ‪ DrawMode‬ﻣﻦ اﻗﻮى ﺧﺼﺎﺋﺺ ﻧﺎﻓﺬة اﻟﻨﻤﻮذج اﻟﺮﺳﻮﻣﻴﺔ، ﻓﻌﻦ ﻃﺮﻳﻘﻬﺎ‬
‫ﺗﺤﺪد ﻃﺮﻳﻘﺔ اﻟﺘﻔﺎﻋﻞ ﺑﻴﻦ اﻟﺮﺳﻮم اﻟﺘﻲ ﺗﺮﺳﻤﻬﺎ ﺑﻄﺮق اﻟﺮﺳﻢ –آـ ‪ -Line‬ﻣـﻊ اﻟﻨﻘـﺎط‬
‫اﻟﻤﻮﺟﻮدة ﻋﻠﻰ ﻧﺎﻓﺬة اﻟﻨﻤﻮذج. اﻟﻘﻴﻤﺔ اﻻﻓﺘﺮاﺿﻴﺔ ﻟﻬﺬﻩ اﻟﺨﺎﺻـﻴﺔ هـﻲ ‪13-Copy Pen‬‬
‫وﺗﻌﻨﻲ ان اﻟﻠﻮن ﺳﻴﻈﻬﺮ آﻤﺎ هﻮ ﻣﻄﻠﻮب، ﻓﺎﻟﻤﺮﺑﻊ اﻻﺑـﻴﺾ ﺳـﻴﻜﻮن اﺑـﻴﺾ وﻟـﻮ رﺳـﻢ‬
‫ﻋﻠﻰ ﻣﺮﺑﻊ اﺳﻮد، واﻟﺪاﺋﺮة اﻟﺤﻤﺮاء ﺳﺘﺮﺳﻢ ﺣﻤﺮاء وﻟﻮ ﻋﻠﻰ ﺳﻄﺢ ارﺟﻮاﻧﻲ. اﻻ اﻧـﻚ‬
‫ﻓﻲ ﺑﻌﺾ اﻟﺤﺎﻻت اﻟﻔﻨﻴﺔ ﺗﻮد ان ﺗﺮﺳـﻢ رﺳـﻮم ﺗﺘـﺄﺛﺮ ﺑـﺎﻻﻟﻮان اﻟﻤﻮﺟـﻮدة ﻋﻠـﻰ ﻟﻮﺣـﺔ‬
                ‫اﻟﺮﺳﻢ وهﺬا ﻣﺜﺎل واﻗﻌﻲ ﺗﺠﺪﻩ آﺜﻴﺮا ﻓﻲ ﺑﺮاﻣﺞ اﻟﺘﺮآﻴﺐ ﺷﻜﻞ 2-1:‬




                                 ‫)ا(‬




                                ‫)ب(‬




                              ‫)ج(‬
                   ‫ﺷﻜﻞ 2-1: ﺗﺄﺛﻴﺮ اﻟﺨﺎﺻﻴﺔ ‪ DrawMode‬ﻋﻠﻰ ﻣﺨﺮﺟﺎت اﻟﺮﺳﻢ.‬

‫ﺗﻼﺣﻆ ﻓـﻲ اﻟﺸـﻜﻞ 2-1 )ا( ان اﻟﻤﺴـﺘﻄﻴﻞ اﻻزرق اﻟـﺬي رﺳـﻤﻨﺎﻩ ﻋﻠـﻰ اﻟﻤﻨﻄﻘـﺔ‬
‫اﻟﺒﻴﻀﺎء ﻗﺪ رﺳﻢ ﺑﺸﻜﻞ ﺟﻴﺪ ﺟﺪا، وﻳﻈﻬﺮ اﻟﻔـﺮق ﻓـﻲ اﻟﻔـﻦ اﻟﺘﺼـﻤﻴﻤﻲ واﺿـﺤﺎ ﺑـﻴﻦ‬
‫اﻟﺸﻜﻠﻴﻦ )ب( و )ج(، ﻓﻔﻲ اﻟﺸﻜﻞ )ب( ﻗﻤﻨـﺎ ﺑﺮﺳـﻢ اﻟﻤﺴـﺘﻄﻴﻞ اﻻزرق آﻤـﺎ ﻧﺮﻳـﺪﻩ‬
‫ازرق ﻣﻤﺎ اﺛﺮ وﻏﻄﻰ ﻋﻠﻰ اﻟﻨﺺ اﻟﻤﻜﺘﻮب "%05" وﻟﻦ ﻳﺘﻤﻜﻦ اﻟﻤﺴﺘﺨﺪم ﻣﻦ رؤﻳﺘـﻪ،‬
‫اﻣﺎ ﻓﻲ اﻟﺸﻜﻞ )ج( ﻓﻘﺪ اﺳـﺘﺨﺪﻣﻨﺎ اﻟﻘﻴﻤـﺔ اﻟﻤﻨﺎﺳـﺒﺔ ﻟﻠﺨﺎﺻـﻴﺔ ‪ DrawMode‬ﺑﺤﻴـﺚ‬
‫ﺗﻘﻠﺐ اﻟﻠﻮن اﻻزرق اﻟﻰ اﺑﻴﺾ ﻓﻲ ﺣﺎﻟﺔ اﻟﺮﺳﻢ ﻓﻮق اﻟﻠﻮن اﻻﺳﻮد. ﻟﻤﻌﺮﻓﺔ آﻴـﻒ ﺗـﺘﻢ‬
‫ﻋﻤﻠﻴﺔ ﺗﻐﻴﻴﺮ اﻻﻟﻮان، ﻋﻠﻴﻚ ان ﺗﻌﻠﻢ ان اﻻﻟﻮان ﻓﻲ ﺣﻘﻴﻘﺘﻬﺎ ﻣﺎ هـﻲ اﻻ اﻋـﺪاد ﺗﺘﺤـﻮل‬
‫ﺑﺎﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ اﻟﻰ ارﻗﺎم ﺷﺒﻴﻪ ﺑـ 01010111001، اﻟﻠﻮن اﻟـﺬي ﺗﺴـﺘﺨﺪﻣﻪ ﻳﺴـﻤﻰ‬
                                                ‫24‬


‫ﻟﻮن اﻟﻘﻠﻢ ‪ ،Pen Color‬واﻟﻠﻮن اﻟﻤﻮﺟﻮد ﻋﻠﻰ ﻟﻮح او ﺳـﻄﺢ اﻟﺮﺳـﻢ ﻳﺴـﻤﻰ ‪Screen‬‬
 ‫‪ ،Color‬ﻓﺎﻟﻘﻴﻤﺔ ‪ 15-MergePen‬ﻟﻠﺨﺎﺻﻴﺔ ‪ DrawMode‬ﺗﻘﻮم ﺑﺘﻄﺒﻴﻖ اﻟﻤﻌﺎدﻟﺔ اﻟﺘﺎﻟﻴﺔ:‬
‫‪S = S Or P‬‬
‫ﻓﻠﻮ آﺎن اﻟﻠﻮن اﻟﻤﺴﺘﺨﺪم هﻮ 01010101 = 071 واﻟﻠﻮن اﻟﻤﻮﺟﻮد ﻋﻠﻰ اﻟﺸﺎﺷﺔ هـﻮ‬
     ‫10101010 = 58، ﻓﺎن اﻟﻠﻮن اﻟﻨﺎﺗﺞ –ﻣﻦ ﺗﺄﺛﻴﺮ اﻟﻘﻴﻤﺔ ‪ 15-MergePen‬ﺳﻴﻜﻮن:‬

‫‪S‬‬   ‫=‬   ‫10101010‬
‫‪P‬‬   ‫=‬   ‫01010101‬
‫‪S‬‬   ‫=‬   ‫‪S Or P‬‬
‫‪S‬‬   ‫=‬   ‫10101010 ‪10101010 Or‬‬
‫‪S‬‬   ‫=‬   ‫11111111‬

‫11111111 وهــﻮ 552. اذا اردت ﻣﻌﺮﻓــﺔ ﺟﻤﻴــﻊ اﻟﻤﻌــﺎدﻻت اﻟﺘﺎﺑﻌــﺔ ﻟﻠﻘــﻴﻢ اﻻﺧــﺮى،‬
‫ﻓﻤﻜﺘﺒــﺔ ‪ MSDN‬ﺑﻬــﺎ ﺟــﺪول ﺟﻤﻴــﻞ ﺟــﺪا ﺗﺼــﻞ اﻟﻴــﻪ ﺑﻜﺘﺎﺑــﺔ اﻟﺠﻤﻠــﺔ " ‪DrawMode‬‬
                                                     ‫‪ "Property‬ﻓﻲ اﻟﻔﻬﺮس ‪.Index‬‬

                                                              ‫اﻟﺨﺎﺻﻴﺔ ‪:ScaleMode‬‬
‫ﻓﻲ ﺑﺪاﻳﺔ اﻟﻔﺼﻞ وﺑﺎﻟﺘﺤﺪﻳﺪ ﻋﻨﺪ ﻓﻘﺮة "ﺧﺼـﺎﺋﺺ اﻟﻤﻮﻗـﻊ واﻟﺤﺠـﻢ" ذآـﺮت ان اﻟﻮﺣـﺪة‬
‫اﻟﻤﺴﺘﺨﺪﻣﺔ ﻟﻘﻴﺎس اﺣﺪاﺛﻴﺎت ﻣﻮاﻗـﻊ وﻃـﻮل وﻋـﺮض اﻻدوات هـﻲ اﻟﻮﺣـﺪة اﻟﻤﻮﺟـﻮدة‬
‫ﻓــﻲ اﻟﺨﺎﺻــﻴﺔ ‪ .ScaleMode‬ﺗــﻮﻓﺮ ﻟــﻚ هــﺬﻩ اﻟﺨﺎﺻــﻴﺔ 8 ﻗــﻴﻢ ﺗﻤﺜــﻞ وﺣــﺪات ‪Units‬‬
          ‫ـ‬              ‫ـ‬                 ‫ـ‬    ‫ـ‬                ‫ـ‬     ‫ـ‬
‫ﺗﺴ ـﺘﺨﺪم ﻟﻠﻘﻴ ـﺎس ه ـﻲ: ‪ 1-Twip‬واﻟﺘ ـﻲ ﺗﻌ ـﺎدل 765.0 ﺳ ـﻢ، ‪ 2-Point‬ﺗﻌ ـﺎدل 27.0‬    ‫ـ‬
‫اﻧﺶ، ‪ 3-Pixel‬ﺗﻌﺎدل ﻧﻘﻄﺔ واﺣﺪة ﻋﻠـﻰ اﻟﺸﺎﺷـﺔ، ‪ 4-Character‬ﺗﻌـﺎدل 021 ‪Twips‬‬
  ‫ـ‬      ‫ـ‬                    ‫ـ‬         ‫ـ‬    ‫ـ‬              ‫ـ‬                     ‫ـ‬
‫اﻓﻘﻴ ـﺎ و 042 ‪ Twips‬ﻋﺎﻣﻮدﻳ ـﺎ، ‪ 5-Inch‬ﺗﻌ ـﺎدل اﻧ ـﺶ واﺣ ـﺪ، ‪ 6-Milimeter‬ﺗﻌ ـﺎدل ﻣﻠ ـﻢ‬
‫واﺣﺪ، ‪ 7-Centimeter‬ﺗﻌﺎدل واﺣﺪ ﺳﻢ و ‪ 0-User‬وﺣﺪة ﻗﻴﺎس ﺧﺎﺻﺔ ﻳﺘﻢ ﺗﻌﺮﻳﻔﻬﺎ ﻣﻦ‬
                                                                         ‫ﻗﺒﻞ اﻟﻤﺒﺮﻣﺞ.‬
‫اﻟﺨﺎﺻــﻴﺘﺎن ‪ Width‬و ‪ Height‬ﺗﻌــﻮدان ﺑﻌــﺮض وارﺗﻔــﺎع اﻟﻨﺎﻓــﺬة داﺋﻤــﺎ ﺑﺎﻟﻮﺣــﺪة ‪،Twip‬‬
‫ﻓﺎﻟﻘﻴﻤﺔ اﻟﺘﺎﺑﻌﺔ ﻟﻠﺨﺎﺻـﻴﺔ ‪ ScaleMode‬ﺗـﺆﺛﺮ ﻋﻠـﻰ اﻟﻮﺣـﺪة اﻟﻤﺴـﺘﺨﺪﻣﺔ ﻓـﻲ اﻻدوات‬
‫اﻟﻤﺤﻀﻮﻧﺔ ﻓﻘﻂ وﻟﻴﺲ اﻟﺤﺎﺿﻨﺔ، اﻣﺎ ﻟﻤﻌﺮﻓﺔ ﻋﺮض وارﺗﻔﺎع ﻧﺎﻓﺬة اﻟﻨﻤﻮذج ﺑﻮﺣـﺪة ﻏﻴـﺮ‬
‫اﻟـ ‪ ،Twip‬ﻗﻢ ﺑﺘﺤﺪﻳﺪ اﻟﻮﺣـﺪة ﻓـﻲ اﻟﺨﺎﺻـﻴﺔ ‪ ScaleMode‬واﺳـﺘﻌﻠﻢ ﻋـﻦ اﻟﻌـﺮض ﻋـﻦ‬
              ‫ﻃﺮﻳﻖ اﻟﺨﺎﺻﻴﺔ ‪ ScaleWidth‬واﻻرﺗﻔﺎع ﻋﻦ ﻃﺮﻳﻖ اﻟﺨﺎﺻﻴﺔ ‪:ScaleHeight‬‬

‫)(‪Private Sub Form_Paint‬‬
   ‫‪Cls‬‬
   ‫ﺑﺎﻟﺒﻜﺴﻞ ‘ ‪ScaleMode = vbPixels‬‬
   ‫‪Print ScaleHeight‬‬
                                               ‫34‬


  ‫‪Print ScaleWidth‬‬
‫‪End Sub‬‬

‫ﻓـــﻲ اﻟﺤﻘﻴﻘـــﺔ، اﻟﺨﺎﺻـــﻴﺘﺎن ‪ ScaleWidth‬و ‪ ScaleHeight‬ﺗﻌـــﻮدان ﺑﻌـــﺮض وارﺗﻔـــﺎع‬
‫اﻟﻤﺴــﺎﺣﺔ اﻟﺪاﺧﻠﻴــﺔ ﻟﻨﺎﻓــﺬة اﻟﻨﻤــﻮذج، ﺑﻴﻨﻤــﺎ ﺗﺸــﻤﻞ اﻟﺨﺎﺻــﻴﺘﺎن ‪ Width‬و ‪Height‬‬
‫اﻟﻤﺴﺎﺣﺔ اﻟﺪاﺧﻠﻴﺔ واﻟﺨﺎرﺟﻴﺔ اﻟﻤﺘﻤﺜﻠﺔ ﻓﻲ ﺳﻤﻚ ﺣﺪودهﺎ وارﺗﻔـﺎع ﺷـﺮﻳﻂ ﻋﻨﻮاﻧﻬـﺎ.‬
‫ﻣﻊ ذﻟﻚ، ﻟﻦ ﺗﻔﺮق آﺜﻴﺮا ﻣﻌـﻚ ﻓﻨـﺎدرا ﻣـﺎ ﺗﺤﺘـﺎج اﻟﻤﺴـﺎﺣﺔ اﻟﺨﺎرﺟﻴـﺔ ﻟﻠﻨﺎﻓـﺬة، ﻋﻠـﻰ‬
                                                    ‫اﻟﻌﻤﻮم هﺬا اﻟﻜﻮد ﻳﻄﺒﻊ اﻟﻔﺮق:‬

‫)(‪Private Sub Form_Paint‬‬
   ‫‪Cls‬‬
   ‫‪ScaleMode = vbTwips‬‬
   ‫‪Print Height - ScaleHeight‬‬
   ‫‪Print Width - ScaleWidth‬‬
‫‪End Sub‬‬

‫اﺧﻴﺮا، اﻟﻘﻴﻤﺔ ‪ 0-User‬هﻲ وﺣﺪة ﺗﻌـﺮف ﻣـﻦ ﻗﺒـﻞ اﻟﻤﺒـﺮﻣﺞ، ﺗﺴـﺘﻄﻴﻊ ﺗﻌﺮﻳـﻒ وﺣـﺪة‬
‫ﺧﺎﺻــﺔ ﺑــﻚ ﻋــﻦ ﻃﺮﻳــﻖ اﺳــﻨﺎد ﻗــﻴﻢ اﻟــﻰ اﻟﺨﺼــﺎﺋﺺ ‪،ScaleHeight ،ScaleWidth‬‬
‫‪ ScaleLeft‬و ‪ .ScaleTop‬ﻗﺪ ﺗﺤﺘﺎج ﺗﻌﺮﻳﻒ وﺣﺪة ﻗﻴﺎس رﺳـﻢ ﺧﺎﺻـﺔ ﺑـﻚ ﻓـﻲ ﺣـﺎﻻت‬
                 ‫ﻧﺎدرة ﺗﻌﺘﻤﺪ ﻋﻠﻰ ﻋﺮض اﻟﻤﺨﻄﻄﺎت اﻟﺮﺳﻮﻣﻴﺔ ﺑﺸﻜﻞ اﺳﺘﺜﻨﺎﺋﻲ.‬

                                                                ‫ﻃﺮق اﻟﻨﻤﻮذج‬
‫ﺑﻤﺎ ان اﻟﻔﻘﺮة اﻟﺴﺎﺑﻘﺔ ﺗﺤـﺪﺛﺖ ﻋـﻦ وﺣـﺪات اﻟﻘﻴـﺎس اﻟﺘﺎﺑﻌـﺔ ﻟﻠﺨﺎﺻـﻴﺔ ‪،ScaleMode‬‬
‫ﻓﺴﺄﺑﺪأ ﺑﺎﻟﺘﺤﺪث ﻋﻦ اﻟﻄﺮق ‪ ScaleX‬و ‪ .ScaleY‬هﺬﻩ اﻟﻄﺮق ﺗﻤﻜﻨﻚ ﻣﻦ اﺟﺮاء ﻋﻤﻠﻴـﺔ‬
‫ﺗﺤﻮﻳﻞ اﻟﻘﻴﺎﺳﺎت ﺑﻴﻦ اﻟﻮﺣﺪات اﻟﺴـﺎﺑﻘﺔ اﻓﻘﻴـﺎ وﻋﺎﻣﻮدﻳـﺎ. ارﺳـﻞ اﻟﻘﻴﻤـﺔ ﺛـﻢ وﺣـﺪﺗﻬﺎ‬
                                                      ‫اﻻﺻﻠﻴﺔ ﺛﻢ اﻟﻮﺣﺪة اﻟﻤﻄﻠﻮﺑﺔ:‬

‫اﻟﺘﺤﻮﻳﻞ ﻣﻦ ‪ Pixels‬اﻟﻰ ‪‘ Twips‬‬
‫)‪Print ScaleX(100, vbPixels, vbTwips‬‬

‫اﻟﻄﺮﻳﻘﺔ ‪ Show‬ﺗﺆدي اﻟﻰ اﻇﻬﺎر اﻟﻨﻤﻮذج واﻟﻄﺮﻳﻘـﺔ ‪ Hide‬ﺗﺨﻔﻴـﻪ، ﻧﺴـﺘﻄﻴﻊ ان ﻧﻘـﻮل‬
                   ‫ﺑﻜﻞ ﺛﻘﺔ اﻧﻬﻤﺎ ﻳﻤﺜﻼن اﻟﺨﺎﺻﻴﺔ ‪ Visible‬وﻟﻜﻦ ﻋﻠﻰ ﺷﻜﻞ ﻃﺮق:‬

‫‪Form1.Show ‘ Form1.Visible = True‬‬
‫‪Form1.Hide ‘ Form1.Visible = False‬‬
                                               ‫44‬


                                                                    ‫ﻃﺮق اﻟﺮﺳﻢ‬
‫اﻟﻄﺮﻳﻘــﺔ ‪ Cls‬ﺗﻤﺴــﺢ ﺟﻤﻴــﻊ اﻟﺮﺳــﻮم اﻟﻤﻮﺟــﻮدة ﻋﻠــﻰ اﻟﻨﺎﻓــﺬة وﺗﺼــﻔﺮ اﻻﺣــﺪاﺛﻴﺎت‬
‫‪ CurrentX‬و ‪ CurrentY‬اﻟﻰ اﻻﺣﺪاﺛﻲ )0 ,0(، واﻟﻄﺮﻳﻘﺔ ‪ Point‬ﺗﻌﻮد ﺑﺎﻟﻘﻴﻤـﺔ اﻟﻌﺪدﻳـﺔ‬
                                    ‫ﻟﻠﻮن اﻟﻤﻮﺟﻮد ﻓﻲ اﻻﺣﺪاﺛﻲ )‪ (x, y‬ﻋﻠﻰ اﻟﻨﺎﻓﺬة:‬

‫)(‪Private Sub Form_Load‬‬
   ‫ﺗﺤﻤﻴﻞ ﺻﻮرة وﺟﻬﻲ اﻟﻮﺳﻴﻢ! '‬
   ‫)”‪Form1.Picture = LoadPicture (“C:\Turki.BMP‬‬
‫‪End Sub‬‬

‫_ ,‪Private Sub Form_MouseMove(Button As Integer, Shift As Integer‬‬
        ‫)‪X As Single, Y As Single‬‬
   ‫)‪Label1.BackColor = Point(X, Y‬‬
   ‫))‪Label1.Caption = Hex$(Point(X, Y‬‬
‫‪End Sub‬‬

‫اﻟﻄﺮﻳﻘﺔ ‪ PSet‬ﺗﻤﻜﻨﻚ ﻣﻦ رﺳﻢ ﻧﻘﻄﺔ ﻋﻠﻰ اﻟﻨﺎﻓﺬة ﺑﺎرﺳﺎل اﻻﺣﺪاﺛﻲ )‪ (X, Y‬ﻟﻠﻨﻘﻄﺔ،‬
‫ﺳﻴﻜﻮن ﻟﻮن اﻟﻨﻘﻄﺔ هـﻮ ﻧﻔـﺲ اﻟﻠـﻮن اﻟﻤﻮﺟـﻮد ﻓـﻲ اﻟﺨﺎﺻـﻴﺔ ‪ ForeColor‬او ﺑﺎﻣﻜﺎﻧـﻚ‬
                                                                 ‫ارﺳﺎل اﻟﻠﻮن:‬

‫‪Me.ForeColor = vbBlack‬‬
‫)0 ,0( ‪PSet‬‬                   ‫ﻧﻘﻄﺔ ﺳﻮداء ‘‬
‫‪PSet (500, 500), vbRed‬‬        ‫ﻧﻘﻄﺔ ﺣﻤﺮاء ‘‬

‫اﻟﻄﺮﻳﻘﺔ ‪– PSet‬وﻃﺮق اﻟﺮﺳﻢ اﻻﺧﺮى- ﺗﺪﻋﻢ اﻟﻜﻠﻤـﺔ اﻟﻤﺤﺠـﻮزة ‪ Step‬واﻟﺘـﻲ ﺗﻀـﻴﻒ‬
    ‫ـ‬        ‫ـ‬      ‫ـ‬
‫اﻻﺣ ـﺪاﺛﻴﺎت اﻟﻤﺮﺳ ـﻠﺔ )‪ (X, Y‬اﻟ ـﻰ اﻻﺣ ـﺪاﺛﻴﺎت اﻟﺤﺎﻟﻴ ـﺔ –اﻟﻤﻮﺟ ـﻮدة ﻓ ـﻲ اﻟﺨﺎﺻ ـﻴﺘﺎن‬
                              ‫ـ‬              ‫ـ‬      ‫ـ‬             ‫ـ‬             ‫ـ‬
                                                              ‫‪ CurrentX‬و ‪:CurrentY‬‬

‫)(‪Private Sub Form_Paint‬‬
   ‫‪Dim X As Integer‬‬

  ‫‪Cls‬‬
  ‫0 = ‪Me.CurrentX‬‬
  ‫0 = ‪Me.CurrentY‬‬

  ‫001 ‪For X = 0 To‬‬
                                              ‫54‬


     ‫)5 ,5(‪PSet Step‬‬
  ‫‪Next‬‬
‫‪End Sub‬‬

‫اﻟﻄﺮﻳﻘﺔ ‪ Line‬ﺗﻤﻜﻨﻚ ﻣﻦ رﺳﻢ اﻟﺨﻄﻮط ﺑﺎرﺳﺎل اﺣـﺪاﺛﻴﺎت اﻟﺒﺪاﻳـﺔ )1‪ (X1, Y‬واﻟﻨﻬﺎﻳـﺔ‬
                                                                    ‫)2‪:(X2, Y‬‬

‫‪ForeColor = vbGreen‬‬
‫)‪Me.Line (0, 0) - (Me.ScaleWidth, Me.ScaleHeight‬‬        ‫ﺧﻂ اﺧﻀﺮ ‘‬
‫ﺧﻂ اﺣﻤﺮ ‘ ‪Me.Line (0, Me.ScaleHeight) - (Me.ScaleWidth, 0), vbRed‬‬

‫ﻓﻲ ﺣﺎﻟـﺔ ﺗﺠﺎهﻠـﻚ ﻟﻼﺣـﺪاﺛﻲ )1‪ (X1, Y‬ﻓـﺎن اﻟﻘـﻴﻢ اﻟﺤﺎﻟﻴـﺔ ﻟﻠﺨﺼـﺎﺋﺺ ‪ CurrentX‬و‬
                                                  ‫‪ CurrentY‬هﻲ ﻧﻘﻄﺔ اﻟﺒﺪاﻳﺔ:‬

‫_ ,‪Private Sub Form_MouseMove(Button As Integer, Shift As Integer‬‬
               ‫)‪X As Single, Y As Single‬‬
   ‫)‪Me.Line - (X, Y‬‬
‫‪End Sub‬‬

‫اﻟﻄﺮﻳﻘﺔ ‪ Line‬ﺗﻤﻜﻨﻚ ﻣﻦ رﺳﻢ اﻟﻤﺴﺘﻄﻴﻼت ﻋﻮﺿـﺎ ﻋـﻦ اﻟﺨﻄـﻮط ﺑﺎرﺳـﺎل اﻟﺤـﺮف ‪B‬‬
‫ﻣﻊ اﻟﻌﻠﻢ ان اﻟﻨﻘﺶ ﺳﻴﻜﻮن اﻟﻨﻘﺶ اﻟﻤﺤﺪد ﻓﻲ اﻟﺨﺎﺻﻴﺔ ‪ FillStyle‬واﻟﻠﻮن ‪:FillColor‬‬

‫‪ForeColor = vbWhite‬‬
‫‪Line (0, 0) - (200, 200), , B‬‬        ‫ﻣﺮﺑﻊ اﺑﻴﺾ ‘‬
‫‪Line – Step (200, 200), vbBlue, B‬‬    ‫ﻣﺮﺑﻊ ازرق ‘‬

             ‫وﻟﺘﻠﻮﻳﻦ اﻟﻤﺮﺑﻊ ﻣﺒﺎﺷﺮة –دون اﺳﺘﺨﺪام اﻟﺨﺼﺎﺋﺺ، ارﺳﻞ اﻟﺤﺮﻓﻴﻦ ‪:BF‬‬

‫‪ForeColor = vbWhite‬‬
‫‪Line (0, 0) - (200, 200), , BF‬‬       ‫ﻣﺮﺑﻊ اﺑﻴﺾ ‘‬
‫‪Line – Step (200, 200), vbBlue, BF‬‬   ‫ﻣﺮﺑﻊ ازرق ‘‬

‫واﺧﺘﻢ ﻓﻘﺮة ﻃﺮق اﻟﺮﺳﻢ ﺑﺎﻟﻄﺮﻳﻘﺔ ‪ Cirlce‬اﻟﺘﻲ ﻣﻦ اﻟﻮاﺿﺢ اﻧﻬﺎ ﻻ ﺗﺮﺳﻢ ﻧﺠﻮم! واﻧﻤﺎ‬
                    ‫دواﺋﺮ ﺑﺎرﺳﺎل اﺣﺪاﺛﻲ ﻧﻘﻄﺔ ﻣﺮآﺰ اﻟﺪاﺋﺮة وﻣﻦ ﺛﻢ ﻃﻮل ﻗﻄﺮهﺎ:‬
                                                  ‫64‬


‫‪ForeColor = vbWhite‬‬
‫005 ,)2 / ‪Circle (Me.ScaleWidth / 2, Me.ScaleHeight‬‬                      ‫داﺋﺮة ﺑﻴﻀﺎء ‘‬
‫‪Circle (Me.ScaleWidth / 2, Me.ScaleHeight / 2), 200, vbGreen‬‬             ‫داﺋﺮة ﺧﻀﺮاء ‘‬

‫ﻋﻤﻠﻴــﺔ ﺗﻠــﻮﻳﻦ اﻟــﺪاﺋﺮة ﻻ ﺗــﺘﻢ ﺑﺎﺳــﺘﺨﺪام ‪ BF‬آﻤــﺎ ﻓــﻲ اﻟﻄﺮﻳﻘــﺔ ‪ ،BF‬واﻧﻤــﺎ ﺑﺎﻟﻘﻴﻤــﺔ‬
                                 ‫اﻟﻤﻮﺟﻮدة ﻓﻲ اﻟﺨﺎﺻﻴﺔ ‪ FillColor‬ﻣﻊ اﻟﻨﻘﺶ ‪.FillStyle‬‬
‫ﻣﻦ اﻻﺷﻴﺎء اﻟﺘﻲ ﺗﻌﺠﺒﻨﻲ ﻓﻲ اﻟﻄﺮﻳﻘﺔ ‪ Cirlce‬هـﻲ اﻣﻜﺎﻧﻴـﺔ رﺳـﻢ اﻻﻗـﻮاس ﺑﺘﺤﺪﻳـﺪ‬
                                           ‫زاوﻳﺔ اﻟﻨﻬﺎﻳﺔ واﻟﺒﺪاﻳﺔ ﺑﻮﺣﺪة اﻟﺮادﻳﺎن ‪:Radian‬‬

‫41.3 = ‪Const PI‬‬
‫ﻧﺼﻒ داﺋﺮة ﻓﺘﺤﻬﺘﻬﺎ اﻟﻰ اﻻﻋﻠﻰ ‘‬
‫‪Circle (Me.ScaleWidth / 2, Me.ScaleHeight / 2), 1000, , 0, PI‬‬
‫ﻧﺼﻒ داﺋﺮة ﻓﺘﺤﻬﺘﻬﺎ اﻟﻰ اﻻﺳﻔﻞ ‘‬
‫0 ,‪Circle (Me.ScaleWidth / 2, Me.ScaleHeight / 2), 800, , PI‬‬
‫رﺑﻊ داﺋﺮة ‘‬
‫2 / ‪Circle (Me.ScaleWidth / 2, Me.ScaleHeight / 2), 500, , 0, PI‬‬

‫ﻣﻦ اﻻﺷﻴﺎء اﻟﺘﻲ ﺗﺰﻳﺪ ﻣﻦ ﻗﻮة اﻟﻄﺮﻳﻘﺔ ‪ Circle‬هـﻲ اﻣﻜﺎﻧﻴـﺔ اﻳﺼـﺎل اﻃـﺮاف اﻻﻗـﻮاس‬
‫ﺑﻤﺮآﺰ اﻟﺪاﺋﺮة وﺗﻠـﻮﻳﻦ ﺟـﺰء ﻣﻌـﻴﻦ آﻤـﺎ ﻳﺤـﺪث ﻣـﻊ اﻟﻤﺨﻄﻄـﺎت ‪ ،Charts‬وﻟﻌﻤـﻞ ذﻟـﻚ‬
                                               ‫ﻳﺸﺘﺮط اﺳﺘﺨﺪام اﻟﻘﻴﻢ اﻟﺴﺎﻟﺒﺔ:‬

‫41.3 = ‪Const PI‬‬
‫0 = ‪FillStyle‬‬
‫‪FillColor = vbBlue‬‬
‫)2 / ‪Circle (Me.ScaleWidth / 2, Me.ScaleHeight / 2), 1000, , - (PI), - (PI‬‬

‫وﻟﺮﺳﻢ اﻟﻘﻄﻊ اﻟﻤﻜﺎﻓﺊ ‪ ،Ellipse‬اﺳﺘﺨﺪم اﻟﻤﺘﻐﻴـﺮ ﻟﻮﺿـﻊ اﻟﻨﺴـﺒﺔ ‪ Ratio‬ﺑـﻴﻦ اﻟﻘﻄـﺮ‬
                                                            ‫اﻟﻌﻤﻮدي واﻻﻓﻘﻲ:‬
‫اﻟﻘﻄﺮ اﻟﻌﻤﻮدي ﻳﻌﺎدل ﺿﻌﻒ اﻟﻘﻄﺮ اﻻﻓﻘﻲ ‘‬
‫2 , , , ,0001 ,)2 / ‪Circle (Me.ScaleWidth / 2, Me.ScaleHeight‬‬

‫اﻣﺎ اﻟﻄﺮﻳﻘﺔ ‪ PaintPicture‬ﻓﻬﻲ اﻗﻮى ﻃﺮق اﻟﺮﺳﻢ واﻟﺘﻲ ﻇﻬـﺮت ﻣﻨـﺬ اﻻﺻـﺪار 5‪،VB‬‬
‫اﻟﻐﺮض ﻣﻦ هﺬﻩ اﻟﻄﺮﻳﻘﺔ هﻮ رﺳﻢ ﺻﻮر ﺗﺎﺑﻌﺔ ﻟﻠﻜﺎﺋﻦ او اﻟﺨﺎﺻﻴﺔ ‪ Picture‬وﺗﻄﻠﺐ ﻣﻨﻚ‬
‫01 ﻣﺘﻐﻴﺮات! ﻻ ﺗﺨﻒ وﺗﺘﺠﻨﺐ اﺳﺘﺨﺪاﻣﻬﺎ ﻟﻜﺜﺮة اﻟﻤﺘﻐﻴـﺮات، ﻓﺎﻟﻤﻄﻠﻮﺑـﺔ هـﻲ اﻟـﺜﻼث‬
‫اﻻوﻟﻰ اﻣﺎ اﻟﺒﺎﻗﻴﺔ ﻓﻬﻲ اﺧﺘﻴﺎرﻳﺔ، ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﺘﻐﻴﺮات ﻓﺎﻷول هﻮ آﺎﺋﻦ اﻟﺼﻮرة، واﻻرﺑـﻊ‬
                                                   ‫74‬


‫اﻟﺘﺎﻟﻴــﺔ ﺗﺤــﺪد ﺑﻬــﺎ اﻟﻤﻨﻄﻘــﺔ اﻟﺘــﻲ ﺳﺘﺮﺳــﻢ اﻟﺼــﻮرة ﻋﻠﻴﻬــﺎ، واﻻرﺑﻌــﺔ اﻟﺘﺎﻟﻴــﺔ ﺗﺤــﺪد‬
‫اﻟﻤﻨﻄﻘﺔ اﻟﺘﻲ ﺗﺮﻳﺪ رﺳﻤﻬﺎ ﻓﻌﻼ ﻣﻦ اﻟﺼﻮرة اﻻﺻﻠﻴﺔ، واﻟﻤﺘﻐﻴـﺮ اﻻﺧﻴـﺮ ﻳﺤـﺪد اﺳـﻠﻮب‬
                 ‫ﺎ‬                          ‫ﺎ‬
‫رﺳﻢ اﻟﺼﻮرة ﻋﻠﻰ اﻟﻬﺪف، وهﻮ ﻳﺘﻄﺎﺑﻖ ﺗﻤﺎﻣـً ﻣـﻊ ﻣـﺎ اوﺿـﺤﺘﻪ ﺳـﺎﺑﻘً ﺣـﻮل ﺧﺎﺻـﻴﺔ‬
                                                                             ‫‪.DrawMode‬‬
‫ﺗﻤﻜﻨﻚ اﻟﻄﺮﻳﻘﺔ ‪ PaintPicture‬ﻣـﻦ ﻓﻌـﻞ اﺷـﻴﺎء آﺜﻴـﺮة ﻋﻠـﻰ اﻟﺼـﻮر، آﻘﻠﺒﻬـﺎ، ﻋﻜـﺲ‬
‫اﻟﻮاﻧﻬﺎ، ﺗﻤﺪﻳﺪهﺎ، ﺗﺤﺮﻳﻜﻬﺎ .... اﻟﺦ، ﺗﺠﺪ ﻓﻲ ﻣﻠﻒ اﻟﻜﺘﺎب ‪ Codes.ZIP‬ﻣﺜﺎل ﻳﻌﺮض ﻟـﻚ‬
              ‫ﺗﻄﺒﻴﻘﺎت ﻋﻤﻠﻴﺔ ﻋﻠﻰ اﻟﻄﺮﻳﻘﺔ ‪ PaintPicture‬وهﺬا اﻟﺠﺰء اﻻﺳﺎﺳﻲ ﻣﻨﻪ:‬

‫)(‪Private Sub Form_Paint‬‬
   ‫‪Cls‬‬
   ‫_ ,1‪PaintPicture Picture1.Picture, 0, 0, lWidth‬‬
        ‫‪lHeight1, lX2, lY2, lWidth2, lHeight2, iDrawMode‬‬
‫‪End Sub‬‬

                                                             ‫وﻣﺎزال ‪ Print‬ﻣﻮﺟﻮد‬
‫ﻣــﺎزال ‪ Visual Basic‬ﻣﺤﺘﻔﻈــﺎ ﺑﺴــﻤﺎت ﻟﻐــﺔ ‪ BASIC‬اﻟﻘﺪﻳﻤــﺔ، ﻓــﺎﻻﻣﺮ ‪ Print‬ﻻ ﻳــﺰال‬
‫ﻣﻮﺟﻮد ﻣﻨﺬ ﻣﻨﺘﺼﻒ اﻟﺴﺘﻴﻨﺎت ﺣﺘﻰ اﻻﺻﺪار 6‪ .VB‬ﻟﻴﺲ هﺬا ﻓﻘﻂ، ﺑﻞ ﻣﺎزاﻟـﺖ اﻟﺼـﻴﻎ‬
                ‫اﻟﻘﺪﻳﻤﺔ آﺎﻟﻔﻮاﺻﻞ اﻟﻤﻨﻘﻮﻃﺔ ";" واﻟﻌﺎدﻳﺔ ﻣﺪﻋﻮﻣﺔ ﻓﻲ ‪:Visual Basic‬‬
‫"ﻋﺎدﻳﺔ" ,"ﻓﺎﺻﻠﺔ" ‪Print‬‬
‫"ﻣﻨﻘﻮﻃﺔ" ;"ﻓﺎﺻﻠﺔ" ‪Print‬‬

 ‫رﻏﻢ ان ‪ Print‬ﻣﺼﻨﻒ ﺿـﻤﻦ ﻃـﺮق اﻟﻜﺎﺋﻨـﺎت، اﻻ اﻧـﻪ –ﺗﻘﻨﻴـﺎ- ﻻ ﻳﻌﺘﺒـﺮ‬              ‫ﻣﻼﺣﻈﺔ:‬
 ‫ﻃﺮﻳﻘﺔ. ﻓﻬﻮ ﺣﺎﻟﺔ ﺧﺎﺻﺔ ﺗﻌﻤﺪهﺎ ﻣﻄـﻮروا ‪ Visual Basic‬ﺣﺘـﻰ ﺗﺘـﺰاﻣﻦ‬
                                            ‫اﻟﺘﻮاﻓﻴﻘﻴﺔ ﻣﻊ ﻟﻐﺔ ‪.BASIC‬‬

‫ﻧﻮع وﺣﺠﻢ اﻟﺨﻂ اﻟﻨـﺎﺗﺞ ﻣـﻦ اﻻﻣـﺮ ‪ ،Print‬هـﻮ ﻧﻔـﺲ اﻟﻘـﻴﻢ اﻟﻤﻮﺟـﻮدة ﻓـﻲ اﻟﺨﺎﺻـﻴﺔ‬
‫‪ .Font‬اﻟﺪوال ‪ TextHeight‬و ‪ TextWidth‬ﺗﻔﻴﺪان ﻟﻤﻌﺮﻓﺔ ارﺗﻔﺎع وﻋﺮض اﻟﻨﺺ وﺗﺨﺘﻠـﻒ‬
‫ﺑﺎﺧﺘﻼف ﻧﻮع وﺣﺠﻢ اﻟﺨﻂ ﻟﺘﺘﻤﻜﻦ ﻣﻦ اﺧﺘﻴـﺎر اﻻﺣـﺪاﺛﻲ اﻟﻤﻨﺎﺳـﺐ ﻟﺒـﺪء اﻟﻜﺘﺎﺑـﺔ آﻤـﺎ‬
                              ‫ﻓﻲ اﻟﻜﻮد اﻟﺘﺎﻟﻲ اﻟﺬي ﻳﻜﺘﺐ اﻟﻨﺺ ﻓﻲ وﺳﻂ اﻟﻨﺎﻓﺬة:‬

‫‪Dim sText As String‬‬
‫02 = ‪Font.Size‬‬
‫"ﺗﺮآﻲ اﻟﻌﺴﻴﺮي" = ‪sText‬‬
‫2 / ))‪CurrentX = (ScaleWidth - TextWidth(sText‬‬
‫2 / ))‪CurrentY = (ScaleHeight - TextHeight(sText‬‬
                                                   ‫84‬


‫‪Print sText‬‬

‫اﺧﻴﺮا، ﺟﻤﻴﻊ اﻟﻤﺨﺮﺟﺎت اﻟﻨﺼﻴﺔ ﻋﺒﺎرة ﻋﻦ ﻧﻘﺎط ﺗﺘﺸﻜﻞ ﻓﻲ ﺻﻮرة ﺣﺎﻟﻬﺎ آﺤـﺎل ﻃـﺮق‬
‫اﻟﺮﺳــﻢ، واﻟﺨﺎﺻــﻴﺔ ‪ Image‬هــﻲ اﻟﻤﺴــﺌﻮﻟﺔ ﻋــﻦ ﺣﻔــﻆ اﻟﻤﻌﻠﻮﻣــﺎت اﻟﻜﺎﻣﻠــﺔ ﻟﻬــﺬﻩ‬
                                                                      ‫اﻟﻤﺨﺮﺟﺎت.‬

                                                              ‫اﺣﺪاث اﻟﻨﻤﻮذج‬
‫ﻧﺎﻓﺬة اﻟﻨﻤﻮذج هﻲ اآﺜﺮ آﺎﺋﻦ ﻣﻦ آﺎﺋﻨﺎت ‪ Visual Basic‬ﻳﺤﺘﻮي ﻋﻠـﻰ اﺣـﺪاث، ﻣﻌﻈـﻢ‬
‫اﺣﺪاﺛﻬﺎ ﺗﻢ ﺷﺮﺣﻬﺎ ﻓﻲ ﻓﻘﺮة "اﻻﺣﺪاث اﻟﻤﺸﺘﺮآﺔ". اﻣﺎ اﻻﺣﺪاث اﻟﺨﺎﺻـﺔ ﺑﻬـﺎ ﻓﺘﻔﺠـﺮ‬
                               ‫ﻣﻦ ﺑﺪاﻳﺔ ﺗﺤﻤﻴﻞ اﻟﻨﺎﻓﺬة ﺣﺘﻰ اﻏﻼﻗﻬﺎ ﺑﻬﺬا اﻟﺘﺮﺗﻴﺐ:‬
         ‫‪<- (Deactivate) <- Paint <- Activate <- Resize <- Load <- Initialize‬‬
                                       ‫‪.Terminate <- Unload <- QueryUnload‬‬

 ‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﺤﺪث ‪ Deactivate‬ﻓـﻼ ﻳـﺘﻢ ﺗﻔﺠﻴـﺮﻩ ﺑﻌـﺪ اﻟﺤـﺪث ‪ Paint‬اﻻ‬         ‫ﻣﻼﺣﻈﺔ:‬
 ‫ﻓﻲ ﺣﺎﻟﺔ ﻗﻴﺎم اﻟﻤﺴﺘﺨﺪم ﺑﺘﺤﺪﻳﺪ ﻧﺎﻓﺬة اﺧﺮى ﻓـﻲ ﻧﻔـﺲ اﻟﺒﺮﻧـﺎﻣﺞ،‬
 ‫واذا ﻋﺎد اﻟﻤﺴﺘﺨﺪم اﻟﻰ اﻟﻨﺎﻓﺬة اﻻوﻟﻰ، ﻓﺎن اﻟﺴﻠﺴﺔ اﻟﺴﺎﺑﻘﺔ ﺗﺒـﺪأ‬
                               ‫ﻣﻦ اﻟﺤﺪث ‪... <- Paint <- Activate‬‬

                                                          ‫اﻟﺤﺪث ‪:Initialize‬‬
‫ﻳﺘﻢ ﺗﻔﺠﻴﺮ هﺬا اﻟﺤﺪث ﺑﻤﺠﺮد اﺳﺘﺨﺪام آﺎﺋﻦ اﻟﻨﻤﻮذج ﻓـﻲ اآـﻮادك او اﻧﺸـﺎء ﻧﺴـﺨﺔ‬
‫ﺟﺪﻳﺪة ﻣﻦ آﺎﺋﻦ اﻟﻨﻤﻮذج، ﻳﻘﻮم ‪ Visual Basic‬ﺑﺘﻔﺠﻴﺮ هﺬا اﻟﺤﺪث ﻣﺒﻜﺮا ﺟـﺪا أي ﻗﺒـﻞ‬
                                       ‫اﻧﺸﺎء ﻧﺎﻓﺬة اﻟﻨﻤﻮذج ووﺿﻊ اﻻدوات ﻋﻠﻴﻬﺎ:‬

‫ﻳﺘﻢ ﺗﻔﺠﻴﺮ اﻟﺤﺪث ‪ Initialize‬اﻟﺘﺎﺑﻊ ﻟﻨﻤﻮذج 2‪‘ Form‬‬
‫2‪Dim X As Form‬‬
‫2‪Set X = New Form‬‬

‫ﻗﺪ ﺗﺴﺘﻔﻴﺪ ﻣﻦ هﺬا اﻟﺤﺪث ﻟﺘﻌﻴﻴﻦ ﻗـﻴﻢ اﺑﺘﺪاﺋﻴـﺔ ﻟﻠﻤﺘﻐﻴـﺮات اﻟﺘﺎﺑﻌـﺔ ﻟﻨﺎﻓـﺬة اﻟﻨﻤـﻮذج‬
                                                                  ‫ﻗﺒﻞ اﻧﺸﺎء اﻟﻨﺎﻓﺬة:‬

‫‪Dim sUserName As String‬‬

‫)(‪Private Sub Form_Initialize‬‬
   ‫"ﻣﺴﺘﺨﺪم ﺟﺪﻳﺪ" = ‪sUserName‬‬
                                                   ‫94‬


‫‪End Sub‬‬

                                                                ‫اﻟﺤﺪث ‪:Load‬‬
‫ﻳﺘﻢ ﺗﻔﺠﻴﺮ اﻟﺤﺪث ‪ Load‬ﺑﻤﺠﺮد اﻟﺒـﺪء ﻓـﻲ ﻋﻤﻠﻴـﺔ ﺗﺤﻤﻴـﻞ اﻟﻨﺎﻓـﺬة ﺑﺎﺳـﺘﺨﺪام اﻟﺪاﻟـﺔ‬
                                                                        ‫‪:Load‬‬

‫2‪Load Form‬‬

                     ‫او ﺣﺘﻰ ﻋﻨﺪ ﻗﻴﺎﻣﻚ ﺑﺎﺳﺘﺨﺪام اﺣﺪ ﺧﺼﺎﺋﺼﻬﺎ او اﺳﺘﺪﻋﺎء ﻃﺮﻗﻬﺎ:‬

‫ﻳﺘﻢ ﺗﻔﺠﻴﺮ اﻟﺤﺪث ‪ Load‬اﻟﺘﺎﺑﻊ ﻟﻨﻤﻮذج 2‪‘ Form‬‬
‫ﻗﺒﻞ ﺗﻌﺪﻳﻞ ﻗﻴﻤﺔ اﻟﺨﺎﺻﻴﺔ ‪‘ Caption‬‬
‫”اﻟﻨﺎﻓﺬة اﻟﺜﺎﻧﻴﺔ“ = ‪Form2.Caption‬‬

‫ﻣﻦ اﻟﻀﺮوري ﻣﻌﺮﻓـﺔ ان اﻟﺤـﺪث ‪ Load‬ﻻ ﻳﺘﺴـﺒﺐ ﻓـﻲ ﻇﻬـﻮر اﻟﻨﺎﻓـﺬة ﻓﻬـﻮ ﻳﻘـﻊ ﻋﻨـﺪ‬
‫ﺗﺤﻤﻴــﻞ واﻧﺸــﺎء اﻟﻨﺎﻓــﺬة ﻓﻘــﻂ، ﻓــﻼ ﺗﺤــﺎول اﺳــﺘﺨﺪام اﻻواﻣــﺮ اﻟﺘﺎﺑﻌــﺔ ﻟﻠﻮاﺟﻬــﺔ آـــ‬
‫‪ SetFocus‬او ﻃﺮق اﻟﺮﺳﻢ .... اﻟﺦ. ﻗﺪ ﺗﺴﺘﻔﻴﺪ ﻣﻦ هـﺬا اﻟﺤـﺪث ﺑﻮﺿـﻊ ﻗـﻴﻢ اﺑﺘﺪاﺋﻴـﺔ‬
                                                                                        ‫آـ:‬

‫)(‪Private Sub Form_Load‬‬
   ‫‪Text1.Text = sUserName‬‬
‫‪End Sub‬‬

                                                                       ‫اﻟﺤﺪث ‪:Resize‬‬
‫ﺑﻤﺠــﺮد ان ﺗﻈﻬــﺮ ﻧﺎﻓــﺬة اﻟﻨﻤــﻮذج، ﻓــﺎن اﻟﺤــﺪث ‪ Resize‬ﻳــﺘﻢ ﺗﻔﺠﻴــﺮﻩ او آﻠﻤــﺎ ﻗــﺎم‬
‫اﻟﻤﺴﺘﺨﺪﻳﻢ ﺑﺘﺤﺠﻴﻢ اﻟﻨﺎﻓﺬة وﺗﻐﻴﻴﺮ ﺣﺠﻤﻬـﺎ، ﻗـﺪ ﺗﺴـﺘﺨﺪم هـﺬا اﻟﺤـﺪث ﺑﻜﺜـﺮة ﻋﻨـﺪ‬
‫رﻏﺒﺘﻚ ﻓﻲ ﻣﺤﺎذاة اﻻدوات او ﺗﻐﻴﻴﺮ ﺣﺠﻤﻬﺎ آﻠﻤﺎ ﻗﺎم اﻟﻤﺘﺴﺨﺪم ﺑﺘﻐﻴﻴﺮ ﺣﺠﻢ اﻟﻨﺎﻓﺬة:‬

‫)(‪Private Sub Form_Resize‬‬
   ‫ﺗﻮﺳﻴﻂ اﻻداة ﻋﻠﻰ اﻟﻨﺎﻓﺬة '‬
   ‫_ ,2 / )‪Command1.Move (Me.ScaleWidth - Command1.Width‬‬
        ‫2 / )‪(Me.ScaleHeight - Command1.Height‬‬
‫‪End Sub‬‬
                                              ‫05‬


                                                             ‫اﻟﺤﺪث ‪:Activate‬‬
‫ﻳﺘﻢ ﺗﻔﺠﻴﺮ اﻟﺤﺪث ﺑﻤﺠﺮد ﻇﻬﻮر اﻟﻨﺎﻓﺬة –ﺑﻌﺪ اﻟﺤـﺪث ‪ -Resize‬او ﺑﻤﺠـﺮد آـﻮن اﻟﻨﺎﻓـﺬة‬
‫هﻲ اﻟﻨﺎﻓﺬة اﻟﻨﺸـﻄﺔ ‪ .Active Window‬ﻣـﻊ ذﻟـﻚ، ﻟـﻦ ﻳـﺘﻢ ﺗﻔﺠﻴـﺮ اﻟﺤـﺪث اذا اﻧﺘﻘـﻞ‬
‫اﻟﻤﺴﺘﺨﺪم ﻣﻦ ﺑﺮﻧﺎﻣﺞ ﺁﺧﺮ اﻟﻰ ﺑﺮﻧﺎﻣﺠﻚ، أي أن هﺬا اﻟﺤـﺪث ﻻ ﻳـﺘﻢ ﺗﻔﺠﻴـﺮﻩ إﻻ ﻋﻨـﺪ‬
‫اﻟﺘﻨﻘﻞ ﺑﻴﻦ ﻧﻮاﻓﺬ ﺑﺮﻧﺎﻣﺠﻚ ﻓﻘﻂ. ﻗﺪ ﻳﻔﻴﺪك هﺬا اﻟﺤﺪث ﻓﻲ ﺗﻐﻴﻴـﺮ ﻣﺤﺘﻮﻳـﺎت اﻟﻨﺎﻓـﺬة –‬
‫آﺘﺠﺪﻳﺚ اﻟﺒﻴﺎﻧﺎت- ﺑﻤﺠﺮد ﻗﻴﺎم اﻟﻤﺴﺘﺨﺪم ﺑﺘﻐﻴﻴـﺮ ﻣﺤﺘﻮﻳـﺎت ﻧﺎﻓـﺬة اﺧـﺮى ﻓـﻲ ﻧﻔـﺲ‬
                                                                      ‫اﻟﺒﺮﻧﺎﻣﺞ:‬

‫)(‪Private Sub Form_Activate‬‬
   ‫‪Label1.Caption = Form2.Text1.Text‬‬
‫‪End Sub‬‬

                                                                 ‫اﻟﺤﺪث ‪:Paint‬‬
‫ﻳﺘﻢ ﺗﻔﺠﻴﺮ هﺬا اﻟﺤﺪث آﻠﻤﺎ دﻋﺖ اﻟﺤﺎﺟﺔ اﻟﻰ اﻋﺎدة رﺳﻢ اﻟﻨﺎﻓـﺬة، ﻓﻠـﻮ ﻗﻤـﺖ ﺑﻮﺿـﻊ‬
‫اﻟﻨﺎﻓﺬة س ﻓﻮق اﻟﻨﺎﻓـﺬة ص وﻣـﻦ ﺛـﻢ ﺗﻌـﻮد اﻟـﻰ اﻟﻨﺎﻓـﺬة س، ﻓـﺎن اﻟﺤـﺪث ‪ Paint‬ﻟـﻪ‬
‫ﻧﺼﻴﺐ ﻣﻦ اﻟﻮﻗﻮع، آﺬﻟﻚ ﻋﻨﺪﻣﺎ ﺗﺨﻔـﻲ اﺟـﺰاء ﻣـﻦ اﻟﻨﺎﻓـﺬة وﻣـﻦ ﺛـﻢ ﺗﻈﻬﺮهـﺎ ﺳـﻴﺘﻢ‬
‫ﺗﻔﺠﻴﺮ اﻟﺤﺪث. ﻣﻦ اﻟﻀـﺮوري ﺟـﺪا ﺟـﺪا اﺧﺒـﺎرك ﺑﺎﻧـﻪ ﻓـﻲ ﺣﺎﻟـﺔ آـﻮن ﻗﻴﻤـﺔ اﻟﺨﺎﺻـﻴﺔ‬
‫‪ AutoRedraw‬ﺗﺴﺎوي ‪ True‬ﻓـﺎن اﻟﺤـﺪث ‪ Paint‬ﻟـﻦ ﻳـﺘﻢ ﺗﻔﺠﻴـﺮﻩ ﺣﺘـﻰ ﺗﺤـﺞ اﻟﺒﻘـﺮة‬
‫ﻋﻠﻰ ﻗﺮوﻧﻬﺎ! اﻓﻀﻞ اآﻮاد ﻳﻤﻜﻨﻚ وﺿﻌﻬﺎ ﺑﻴﻦ ﺳﻄﻮر هﺬا اﻟﺤـﺪث هـﻲ اآـﻮاد اﻟﺮﺳـﻢ،‬
                              ‫اﻟﻜﻮد اﻟﺘﺎﻟﻲ ﻳﺮﺳﻢ داﺋﺮة ﺗﻐﻄﻲ ﻣﻌﻈﻢ اﺟﺰاء اﻟﻨﺎﻓﺬة:‬

‫)(‪Private Sub Form_Paint‬‬
   ‫‪Cls‬‬
   ‫0 = ‪FillStyle‬‬
   ‫_ ,)2 / ‪Circle (ScaleWidth / 2, ScaleHeight‬‬
         ‫0 ,2 / )‪IIf(ScaleWidth < ScaleHeight, ScaleWidth, ScaleHeight‬‬
‫‪End Sub‬‬

‫ﻣﻦ اﻟﻤﻔﻴﺪ ان اذآﺮ هﻨﺎ ﺑﺎن ﺗﻐﻴﻴﺮ ﺣﺠﻢ اﻟﻨﺎﻓﺬة ﻳـﺆدي اﻟـﻰ ﺗﻔﺠﻴـﺮ اﻟﺤـﺪث ‪ Paint‬ﻓـﻲ‬
‫ﺣﺎﻟﺔ ان ﻗﺎم اﻟﻤﺴﺘﺨﺪم ﺑﺘﻜﺒﻴﺮ اﻟﺤﺠﻢ، اﻣﺎ ﻋﻨﺪ ﺗﺼـﻐﻴﺮ اﻟﺤﺠـﻢ ﻓـﺎن اﻟﺤـﺪث ‪ Paint‬ﻻ‬
‫ﻳﺘﻢ ﺗﻔﺠﻴﺮﻩ، وذﻟﻚ ﻻﻧﻪ ﻻ ﺗﻮﺟﺪ ﺣﺎﺟﺔ ﻻﻋﺎدة رﺳﻢ اﺟﺰاء ﻣﻦ اﻟﻨﺎﻓﺬة، ﻓﻘﺪ ﺗﻼﺣﻆ ﻓـﻲ‬
‫اﻟﻜﻮد اﻟﺴﺎﺑﻖ اﻧﻚ اذا ﻗﻤﺖ ﺑﺘﺼﻐﻴﻴﺮ ﺣﺠﻢ اﻟﻨﺎﻓﺬة، ﻓﺎن اﻟﺪاﺋﺮة ﻟﻦ ﻳﺘﻢ اﻋﺎدة رﺳـﻤﻬﺎ،‬
‫واﻟﻔﻜﺮة اﻟﺬآﻴﺔ اﻟﺘﻲ ﻗﺪ ﺗﺠﺒﺮ ‪ Visual Basic‬ﻻﻋﺎدة رﺳﻢ اﻟـﺪاﺋﺮة هـﻲ ﻃﺮﻳـﻖ اﻟﺤـﺪث‬
                                                                       ‫‪:Resize‬‬
                                                 ‫15‬


‫)(‪Private Sub Form_Resize‬‬
   ‫‪Form_Paint‬‬
‫‪End Sub‬‬

‫رﻏﻢ ان اﻟﻜﻮد اﻟﺴﺎﺑﻖ ﺻﺤﻴﺢ، اﻻ اﻧﻪ ﻻ ﻳﺨﺮج ﻣﻦ اﺻﺎﺑﻊ ﻣﺒـﺮﻣﺞ ﺣﺮﻳـﻒ، واﻟﺴـﺒﺐ ان‬
   ‫ـ‬        ‫ـ‬     ‫ـ‬            ‫ـ‬
‫اﻟﺤ ـﺪث ‪ Paint‬ﺳ ـﻴﺘﻢ ﺗﻨﻔﻴ ـﺬﻩ ﻣ ـﺮﺗﻴﻦ آﻠﻤ ـﺎ ﻗ ـﺎم اﻟﻤﺴ ـﺘﺨﺪم ﺑﺘﻜﺒﻴﻴ ـﺮ ﺣﺠ ـﻢ اﻟﻨﺎﻓ ـﺬة،‬
                                        ‫ـ ـ‬            ‫ـ‬     ‫ـ‬         ‫ـ‬           ‫ـ‬
‫ﻓــﺎﻷوﻟﻰ ﺑﺴــﺒﺐ اﻋــﺎدة اﻟﺮﺳــﻢ واﻟﺜﺎﻧﻴــﺔ ﺑﺴــﺒﺐ اﻻﺳــﺘﺪﻋﺎء اﻟﻤﻮﺟــﻮد ﻓــﻲ اﻟﺤــﺪث‬
‫‪ ،Resize‬ﻟﺬﻟﻚ ﺗﺠﺪ ان اﻟﻤﺒﺮﻣﺞ اﻟﺬآﻲ ﻻ ﻳﺴﺘﺪﻋﻲ اﻟﺤﺪث ‪ Fomr_Paint‬ﻣﺒﺎﺷﺮة ﺑـﻞ‬
    ‫ﻳﺘﺮك اﻻﻣﺮ ﻟـ ‪ Visual Basic‬ﻟﻴﻔﻌﻠﻪ ﻋﻨﺪ وﻗﺖ اﻟﺤﺎﺟﺔ ﺑﺎﺳﺘﺨﺪام اﻟﻄﺮﻳﻘﺔ ‪:Refresh‬‬

‫)(‪Private Sub Form_Resize‬‬
   ‫‪Me.Refresh‬‬
‫‪End Sub‬‬

‫ﺑﻌﺪ اﻟﺤﺪث اﻟﺘﻠﻘﺎﺋﻲ اﻻﺧﻴـﺮ ‪ Paint‬ﺗﻜـﻮن ﻧﺎﻓـﺬة اﻟﻨﻤـﻮذج ﺟـﺎهﺰة ﻻﺳـﺘﻘﺒﺎل اﻻﺣـﺪاث‬
‫اﻟﺨﺎﺻﺔ ﻟﺒﺎﻗﻲ اﻻدوات او اﺣﺪاﺛﻬﺎ اﻻﺧﺮى آـ ‪ Click‬وﻏﻴﺮهﺎ، اﻣﺎ ﻓﻲ ﺣﺎﻟـﺔ ﻋـﺪم وﺟـﻮد‬
‫أي اداة ﻗﺎﺑﻠﺔ ﻻﺳﺘﻘﺒﺎل اﻟﺘﺮآﻴﺰ، ﻓﺎن اﻟﺤﺪث ‪ GotFocus‬اﻟﺨﺎص ﺑﻨﺎﻓﺬة اﻟﻨﻤﻮذج ﺳﻴﺘﻢ‬
                                                                  ‫ﺗﻔﺠﻴﺮﻩ ﻓﻮرا.‬

                                                           ‫اﻟﺤﺪث ‪:Deactivate‬‬
‫هﻮ ﻋﻜﺲ اﻟﺤﺪث ‪ Activate‬وﻳﺘﻢ ﺗﻔﺠﻴﺮﻩ ﺑﻤﺠﺮد ان ﻳﻨﺘﻘـﻞ اﻟﺘﺮآﻴـﺰ اﻟـﻰ ﻧﺎﻓـﺬة اﺧـﺮى‬
‫ﺗﺎﺑﻌﺔ ﻟﺒﺮﻧﺎﻣﺠﻚ ﻓﻘﻂ. ﻗﺪ ﻳﻨﻔﺬ هﺬا اﻟﺤـﺪث اﻳﻀـﺎ ﻓـﻲ ﺣﺎﻟـﺔ اﻻﺧﻔـﺎء اﻟﻤﺆﻗـﺖ ﻟﻠﻨﺎﻓـﺬة‬
               ‫ﺑﺎﺳﺘﺨﺪام اﻟﻄﺮﻳﻘﺔ ‪ Hide‬او ﺗﻌﺪﻳﻞ ﻗﻴﻤﺔ اﻟﺨﺎﺻﻴﺔ ‪ Visible‬اﻟﻰ ‪.False‬‬

                                                      ‫اﻟﺤﺪث ‪:QueryUnload‬‬
‫ﻳﺘﻢ ﺗﻨﻔﻴﺬ اﻟﺤﺪث ‪ QueryUnload‬ﻋﻨﺪﻣﺎ ﺗﻜﻮن اﻟﻨﺎﻓﺬة ﻋﻠﻰ وﺷﻚ اﻻزاﻟﺔ اﻟﻨﻬﺎﺋﻴـﺔ ﻣـﻦ‬
‫اﻟﺬاآﺮة –وﻟﻴﺲ اﻻﺧﻔﺎء اﻟﻤﺆﻗﺖ. ﻳﻤﻜﻨﻚ هﺬا اﻟﺤﺪث ﻣﻦ اﻻﺳﺘﻌﻼم ﻋﻦ اﻟﻄﺮﻳﻘﺔ اﻟﺘﻲ‬
‫ﺗﺴﺒﺒﺖ ﻓﻲ اﻏﻼق اﻟﻨﺎﻓﺬة ﻋﻦ ﻃﺮﻳﻖ اﻟﻤﺘﻐﻴﺮ اﻟﻤﺮﺳـﻞ ‪ .UnloadMode‬اﻟﻤﺰﻳـﺪ اﻳﻀـﺎ،‬
 ‫ـ‬          ‫ـ‬         ‫ـ‬       ‫ـ‬    ‫ـ‬
‫ﺗﺴـﺘﻄﻴﻊ اﻟﻐـﺎء ﻓﻜـﺮة اﻏـﻼق اﻟﻨﺎﻓـﺬة ﻋـﻦ ﻃﺮﻳـﻖ اﺳـﻨﺎد اﻟﻘﻴﻤـﺔ ‪ True‬اﻟـﻰ اﻟﻤﺘﻐﻴـﺮ‬
                                         ‫ـ‬    ‫ـ‬        ‫ـ‬     ‫ـ‬     ‫ـ‬        ‫ـ‬
‫اﻟﻤﺮﺳﻞ ‪ ،Cancel‬ﻓﺎﻟﻜﻮد اﻟﺘﺎﻟﻲ ﻟﻦ ﻳﻤﻜﻦ اﻟﻤﺴﺘﺨﺪم ﻣﻦ اﻏﻼق اﻟﻨﺎﻓـﺬة ﺑﺎﺳـﺘﺨﺪام‬
          ‫ﺻﻨﺪوق اﻟﺘﺤﻜﻢ ‪ Control Box‬او اﻟﺰر اﻏﻼق "‪ "X‬اﻟﻤﻮﺟﻮد ﻓﻲ اﻋﻠﻰ اﻟﻨﺎﻓﺬة:‬

‫)‪Private Sub Form_QueryUnload(Cancel As Integer, UnloadMode As Integer‬‬
   ‫‪If UnloadMode = vbFormControlMenu Then‬‬
      ‫‪Cancel = True‬‬
                                                  ‫25‬


  ‫‪End If‬‬
‫‪End Sub‬‬

‫ﻃــﺮق اﻻﺳــﺘﻌﻼم اﻻﺧــﺮى ﻋــﻦ ﻗــﻴﻢ اﻟﻤﺘﻐﻴــﺮ ‪ UnloadMode‬ﻣﻮﺟــﻮدة ﻓــﻲ ﺗﻌﻠﻴﻤــﺎت‬
                                                                        ‫‪.MSDN‬‬

                                                          ‫اﻟﺤﺪث ‪:Unload‬‬
‫ان ﻟﻢ ﺗﻘﻢ ﺑﺎﻟﻐﺎء ﻋﻤﻠﻴﺔ اﻏﻼق اﻟﻨﺎﻓﺬة ﻓﻲ اﻟﺤﺪث اﻟﺴﺎﺑﻖ، ﻓﺎن اﻟﺤـﺪث ‪ Unload‬هـﻮ‬
‫اﻟﺤﺪث اﻟﺘﺎﻟﻲ، ﻣﻌﻄﻴﻚ ﻓﺮﺻﺔ اﺧﻴﺮة ﻻﻟﻐـﺎء ﻋﻤﻠﻴـﺔ اﻏـﻼق اﻟﻨﺎﻓـﺬة ﻋـﻦ ﻃﺮﻳـﻖ ﻧﻔـﺲ‬
      ‫اﻟﻤﺘﻐﻴﺮ اﻟﻤﺮﺳﻞ ‪ ،Cancel‬اﻣﺎ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﺘﻐﻴﺮ ‪ UnloadMode‬ﻓﻬﻮ ﻏﻴﺮ ﻣﻮﺟﻮد.‬

                                                          ‫اﻟﺤﺪث ‪:Terminate‬‬
‫ﻳﺘﻢ ﺗﻔﺠﻴﺮ هﺬا اﻟﺤﺪث ﺑﻤﺠﺮد ﻣـﻮت آـﺎﺋﻦ اﻟﻨﻤـﻮذج، ﻣﻮﺿـﻮع ﻣـﻮت اﻟﻜﺎﺋﻨـﺎت هـﻮ اﺣـﺪ‬
                            ‫ﻓﻘﺮات اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ "اﻟﺒﺮﻣﺠﺔ آﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ ‪."OOP‬‬

                                                                  ‫اﻟﻘﻮاﺋﻢ ‪Menus‬‬
‫ﻳﻤﻜﻨﻚ ‪ Visual Basic‬ﻣـﻦ ﺗﺼـﻤﻴﻢ ﻗﺎﺋﻤـﺔ ‪ Menu‬ﻟﻨﻮاﻓـﺬ اﻟﻨﻤـﺎذج وﻗـﺖ اﻟﺘﺼـﻤﻴﻢ ﻋـﻦ‬
‫ﻃﺮﻳﻖ ﺻﻨﺪوق اﻟﺤﻮار ﻣﺤﺮر اﻟﻨﻤﺎذج ‪ ،Menu Editor‬ﺣﺪد ﻧﺎﻓﺬة اﻟﻨﻤﻮذج ﺛﻢ اﺧﺘـﺮ اﻻﻣـﺮ‬
  ‫ـ‬        ‫ـ‬       ‫ـ‬      ‫ـ‬
‫…‪ Menu Editor‬ﻣ ـﻦ ﻗﺎﺋﻤ ـﺔ ‪ .Tools‬واذا آﻨ ـﺖ ﺗﻌ ـﺎﻧﻲ ﻣ ـﻦ آﺜ ـﺮة اﻋ ـﺎدة ﺗﻜ ـﺮار ﺗﻌﺒﺌ ـﺔ‬
                                 ‫ـ‬     ‫ـ‬     ‫ـ‬                 ‫ـ‬       ‫ـ‬
‫ﻣﺤﺘﻮﻳﺎت اﻟﻘﻮاﺋﻢ، ﺗﺴﺘﻄﻴﻊ اﺳـﺘﺨﺪام ﻗﻮاﻟـﺐ اﻟﻘﻮاﺋـﺐ ‪ Template Menu‬ﻋـﻦ ﻃﺮﻳـﻖ‬
                                ‫اﻻﺿﺎﻓﺔ ‪ Add-In‬ﻣﺪﻳﺮ اﻟﻘﻮاﻟﺐ ‪.VB6 Template Manager‬‬
‫ﻣﺒﺪﺋﻴﺎ، آﻞ وﺣﺪة ﻣﻦ وﺣـﺪات اﻟﻘﺎﺋﻤـﺔ ﺗﺤﺘـﻮي ﻋﻠـﻰ اﻟﺨﺎﺻـﻴﺔ ‪ Caption‬اﻟﺘـﻲ ﺗﻤﺜـﻞ‬
‫اﻟﻨﺺ اﻟﻈﺎهﺮ ﻋﻠﻰ اﻟﻘﺎﺋﻤﺔ، اﺳﺘﺨﺪم اﻟﺮﻣﺰ "&" ﻟﻮﺿﻊ ﺧـﻂ ﺗﺤـﺖ اﻟﺤـﺮف اﻟـﺬي ﻳﻠﻴـﻪ‬
‫ﺣﺘﻰ ﺗﻤﻜﻦ اﻟﻤﺴﺘﺨﺪم ﻣﻦ اﻟﻮﺻﻮل اﻟﻰ اﻻﻣﺮ ﻓﻲ اﻟﻘﺎﺋﻤﺔ ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ اﻟﻤﻔﺘـﺎح ‪Alt‬‬
‫واﻟﺤﺮف اﻟـﺬي ﻳﻠـﻲ اﻟﺮﻣـﺰ، واذا آﺎﻧـﺖ ﻗﻴﻤـﺔ اﻟﺨﺎﺻـﻴﺔ ‪ Caption‬اﻟﺮﻣـﺰ "-" ﻓﻘـﻂ، ﻓـﺎن‬
‫اﻟﻘﺎﺋﻤﺔ ﺳﺘﻜﻮن ﻋﺒﺎرة ﻋﻦ ﺧـﻂ ﻓﺎﺻـﻞ. اﻣـﺎ اﻟﺨﺎﺻـﻴﺔ ‪ Name‬ﺗﻤﺜـﻞ اﻻﺳـﻢ اﻟﺒﺮﻣﺠـﻲ‬
‫ﻟﻠﻘﺎﺋﻤﺔ واﻟﺬي ﺗﻨﻄﺒﻖ ﻋﻠﻴﻪ ﻧﻔﺲ ﺷﺮوط اﻻدوات ﻓﻲ اﻟﺘﺴﻴﻤﺔ، ﻓﺎﻟﻘﺎﺋﻤـﺔ ﻣـﺎهﻲ اﻻ‬
‫أداة ﻟﻜﻦ ﻣﻦ ﻧـﻮع ﺧـﺎص، ﻓﺒﺎﻣﻜﺎﻧـﻚ آﺘﺎﺑـﺔ اآـﻮاد ﺗﻌـﺪل ﻓـﻲ ﺧﺼـﺎﺋﺺ اﻟﻘﺎﺋﻤـﺔ وﻗـﺖ‬
                                                                                 ‫اﻟﺘﻨﻔﻴﺬ:‬

‫”&ﻣﻠﻒ“ = ‪mnuFile.Caption‬‬
‫‪mnuEdit.Enabled = False‬‬
                                                ‫35‬


‫آﻤﺎ ان اﻟﺨﺼﺎﺋﺺ ‪ Visible‬و ‪ Enabled‬ﻣﻮﺟﻮدة ﻓﻲ اﻟﻘـﻮاﺋﻢ وﺗـﺆﺛﺮ ﺣﺘـﻰ ﻓـﻲ اﻟﻘـﻮاﺋﻢ‬
‫اﻟﻔﺮﻋﻴﺔ اﻟﺘﺎﺑﻌﺔ ﻟﻬﺎ. واﻟﺨﺎﺻﻴﺔ ‪ Checked‬ﺗﺤﺪد ﻣـﺎ اذا آﻨـﺖ ﺗﺮﻳـﺪ وﺿـﻊ ﻋﻼﻣـﺔ اﺧﺘﻴـﺎر‬
‫ﺑﺠﺎﻧﺐ ﻋﻨـﻮان اﻟﻘﺎﺋﻤـﺔ. اﻣـﺎ اﻟﺨﺎﺻـﻴﺔ ‪ WindowList‬ﻓﻬـﻲ ﺗﻤﻜـﻦ اﻟﻘﺎﺋﻤـﺔ ﻣـﻦ ﻋـﺮض‬
                                ‫ﺟﻤﻴﻊ اﻟﻨﻮاﻓﺬ اﻟﻤﺤﻀﻮﻧﺔ ﻓﻲ اﻟﻨﺎﻓﺬة ﻣﻦ اﻟﻨﻮع ‪.MDI‬‬

                                          ‫اﻟﻘﻮاﺋﻢ اﻟﻤﻨﺒﺜﻘﺔ ‪:Pop-Up Menus‬‬
‫اذا ﻧﻘﺮت ﺑـﺰر اﻟﻔـﺄرة اﻻﻳﻤـﻦ ﻋﻠـﻰ أي آـﺎﺋﻦ، ﻓـﺎن ﻗﺎﺋﻤـﺔ ﺻـﻐﻴﺮة ﺳـﺘﻈﻬﺮ ﻟـﻚ. هـﺬﻩ‬
‫اﻟﻘﺎﺋﻤـﺔ ﺗﺴـﻤﻰ ‪ .Pop-Up Menu‬ﺗﺴـﺘﻄﻴﻊ ﺗﻄﺒﻴﻘﻬـﺎ ﻓـﻲ ‪ Visual Basic‬ﻋـﻦ ﻃﺮﻳـﻖ‬
                          ‫اﻻﻣﺮ ‪ PopupMenu‬ﻣﻊ ﺗﺤﺪﻳﺪ اﻟﻘﺎﺋﻤﺔ اﻟﺘﻲ ﺗﻮد ﻋﺮﺿﻬﺎ:‬

‫_ ,‪Private Sub Form_MouseDown(Button As Integer, Shift As Integer‬‬
               ‫)‪X As Single, Y As Single‬‬
   ‫‪If Button And vbRightButton Then‬‬
      ‫‪PopupMenu mnuView‬‬
   ‫‪End If‬‬
‫‪End Sub‬‬

                                  ‫آﻤﺎ ﻳﻤﻜﻨﻚ ﻋﺮض ﻗﺎﺋﻤﺔ ﺗﺎﺑﻌﺔ ﻟﻨﺎﻓﺬة ﻧﻤﻮذج اﺧﺮى:‬

‫‪PopupMenu frmMain.mnuHelp‬‬



                                                                   ‫اﻻدوات اﻟﺪاﺧﻠﻴﺔ‬
           ‫ـ‬   ‫ـ‬     ‫ـ‬
‫ﻓﻴﻤـﺎ ﻳﻠـﻲ ﻋـﺮض ﻣﻠﺨـﺺ ﻟﺠﻤﻴـﻊ اﻻدوات اﻟﺪاﺧﻠﻴـﺔ اﻟﻤﻮﺟـﻮدة ﻓـﻲ ﺻـﻨﺪوق اﻻدوات‬
                             ‫ـ‬                ‫ـ‬         ‫ـ‬         ‫ـ‬     ‫ـ ـ‬
                                       ‫‪ ToolBox‬واﻟﺒﺪاﻳﺔ ﻣﻊ أداة اﻟﻌﻨﻮان ‪:Label‬‬

                                                           ‫أداة اﻟﻌﻨﻮان ‪Label‬‬
‫اداة اﻟﻌﻨﻮان ﻣﻦ اﻻدوات اﻟﻤﻌﺪوﻣﺔ اﻟﻨﻮاﻓﺬ ‪ Windowless Controls‬ﺣﻴﺚ ﺗﻌﺮض اﻟـﻨﺺ‬
‫اﻟﻤﻮﺟﻮد ﻓـﻲ اﻟﺨﺎﺻـﻴﺔ ‪ Caption‬اﻟﺘﺎﺑﻌـﺔ ﻟﻬـﺎ، ﻓـﻲ ﺣﺎﻟـﺔ آﺘﺎﺑـﺔ اﻟﺮﻣـﺰ "&" ﻗﺒـﻞ اﺣـﺪ‬
‫اﻟﺤﺮوف ﻓﻲ هﺬﻩ اﻟﺨﺎﺻﻴﺔ، ﻓﺎن ﺧـﻂ ﺻـﻐﻴﺮ ﻳـﺘﻢ ﺗﺴـﻄﻴﺮﻩ ﺗﺤـﺖ ذﻟـﻚ اﻟﺤـﺮف ﻳﻤﻜـﻦ‬
‫اﻟﻤﺴــﺘﺨﺪم ﻣــﻦ ﻧﻘــﻞ اﻟﺘﺮآﻴــﺰ اﻟــﻰ اﻻداة اﻟﺘــﻲ ﺗﻠــﻲ أداة اﻟﻌﻨــﻮان ﻓــﻲ اﻟﺨﺎﺻــﻴﺔ‬
‫‪ TabIndex‬اذا ﺿــﻐﻂ ﻋﻠــﻰ اﻟﻤﻔﺘــﺎح ]‪ [Alt‬وذﻟــﻚ اﻟﺤــﺮف، ﺗﺴــﺘﻄﻴﻊ اﻟﻐــﺎء اﻟﺨﺪﻣــﺔ‬
                          ‫اﻟﺴﺎﺑﻘﺔ ﺑﺘﺤﻮﻳﻞ ﻗﻴﻤﺔ اﻟﺨﺎﺻﻴﺔ ‪ UseMnemonic‬اﻟﻰ ‪.False‬‬
                                               ‫45‬


 ‫اذا اردت ﻋـــﺮض اﻟﺮﻣـــﺰ "&" ﻋﻠـــﻰ اﻷداة وآﺎﻧـــﺖ ﻗﻴﻤـــﺔ اﻟﺨﺎﺻـــﻴﺔ‬   ‫ﻣﻼﺣﻈﺔ:‬
           ‫‪ UseMnemonic‬ﺗﺴﺎوي ‪ ،True‬ﻓﻴﺸﺘﺮط آﺘﺎﺑﺔ اﻟﺮﻣﺰ ﻣﺮﺗﻴﻦ.‬

‫اﻟﺨﺎﺻﻴﺔ ‪ BorderStyle‬ﺗﻈﻬﺮ ﺣﺪود ﺣـﻮل اﻻداة، واﻟﺨﺎﺻـﻴﺔ ‪ Alignment‬ﺗﺤـﺎذي اﻟـﻨﺺ‬
‫اﻟﻤﻮﺟﻮد ﻓـﻲ اﻻداة اﻣـﺎ ﻣـﻦ اﻟﻴﺴـﺎر اﻟـﻰ اﻟﻴﻤـﻴﻦ ‪ ،0-Left Justify‬ﻣـﻦ اﻟﻴﻤـﻴﻦ اﻟـﻰ‬
‫اﻟﻴﺴـﺎر ‪ 1-Right Justify‬او ﻓـﻲ اﻟﻮﺳـﻂ ‪ .2-Center‬اﻣـﺎ اﻟﺨﺎﺻـﻴﺔ ‪ WordWrap‬ﻓﻬـﻲ‬
‫ﻣﻔﻴﺪة ﺟﺪا ﻟﻠﻨﺼﻮص اﻟﻄﻮﻳﻠﺔ ﺣﻴﺚ ﺗﻘﻮم ﺑﺎزاﺣﺔ اﻟـﻨﺺ اﻟـﻰ ﺳـﻄﺮ ﺟﺪﻳـﺪ آﻠﻤـﺎ وﺻـﻞ‬
‫ﺣﺪود اﻷداة. اﻟﺨﺎﺻﻴﺔ ‪ BackStyle‬ﺗﺤﺪد ﻣـﺎ اذا آﻨـﺖ ﺗﺮﻳـﺪ ﺟﻌـﻞ أداة اﻟﻌﻨـﻮان ﺷـﻔﺎﻓﺔ‬
                                              ‫ﺑﺤﻴﺚ ﺗﻈﻬﺮ اﻻدوات اﻟﺘﻲ ﺧﻠﻔﻬﺎ او ﻻ.‬
‫ﺑﺎﻻﺿﺎﻓﺔ اﻟﻰ ﻋﺮض اﻟﻨﺼﻮص، ﻳﻮﺟﺪ اﺳﺘﺨﺪام ﺟﻤﻴﻞ ﻻداة اﻟﻌﻨﻮان اﻃﺒﻘـﻪ ﺑﻜﺜـﺮة ﻓـﻲ‬
‫ﺑﺮاﻣﺠﻲ، ﺣﻴﺚ اﺿﻊ ﻣﺠﻤﻮﻋﺔ ادوات اﻟﻌﻨﻮان ﻋﻠﻰ اﻟﻨﺎﻓﺬة اﻟﺘـﻲ ﺗﺤﺘـﻮي ﻋﻠـﻰ ﺻـﻮرة‬
‫ﻻزرار واﻗﻮم ﺑﻜﺘﺎﺑﺔ ﺑﻌﺾ اﻻآﻮاد ﻓﻲ اﻟﺤﺪث ‪ Click‬ﻟﻜﻞ أداة، وﻟﺤﺒﻚ اﻟﺤﻴﻠﺔ أﻗﻮم ﺑﻮﺿﻊ‬
‫ﺗﻠﻤﻴﺢ ‪ ToolTip‬ﻟﻜﻞ أداة ﻣﻤـﺎ ﻳـﻮﺣﻲ ﻟﻠﻤﺴـﺘﺨﺪم ان اﻻزرار اﻟﻤﻮﺟـﻮدة ﻋﻠـﻰ اﻟﺼـﻮرة‬
                                                                         ‫ﺣﻘﻴﻘﻴﺔ.‬

                                                        ‫أداة اﻟﻨﺺ ‪TextBox‬‬
‫أداة اﻟـﻨﺺ ‪ Text Box‬ﻣـﻦ اآﺜـﺮ اﻻدوات اﺳـﺘﺨﺪاﻣﺎ ﻓـﻲ ﺗﻄﺒﻴﻘـﺎت ‪ Windows‬ﺑﺸـﻜﻞ‬
‫ﻋﺎم، ﻓﻬﻲ اﻟﻮﺳﻴﻠﺔ اﻟﻤﺜﻠﻰ ﻟﻠﺘﻔﺎﻋﻞ ﻣﻊ اﻟﻤﺴﺘﺨﺪم واﻟﺤﺼﻮل ﻋﻠـﻰ ﻗـﻴﻢ اﻟﻤـﺪﺧﻼت‬
‫ﻣﻨﻪ. ﺑﻌﺪ ان ﺗﻀﻴﻒ أداة ﻧﺺ ﺟﺪﻳﺪة ﻋﻠـﻰ اﻟﻨﺎﻓـﺬة، اﻣﺴـﺢ اﻟـﻨﺺ اﻻﺑﺘـﺪاﺋﻲ ﻟﻬـﺎ ﻋـﻦ‬
                                ‫ـ‬                                               ‫ـ‬
‫ﻃﺮﻳ ـﻖ اﻟﺨﺎﺻــﻴﺔ ‪ .Text‬واذا اردت ﻣﻨــﻊ اﻟﻤﺴــﺘﺨﺪم ﻣ ـﻦ ﺗﻐﻴﻴ ـﺮ ﻣﺤﺘﻮﻳــﺎت أداة اﻟــﻨﺺ،‬
‫ﻓﺎﻟﻘﻴﻤﺔ ‪ True‬ﻟﻠﺨﺎﺻﻴﺔ ‪ Locked‬ﺗﻔﻲ ﺑـﺎﻟﻐﺮض. آﻤـﺎ ان اﻟﺨﺎﺻـﻴﺔ ‪ MaxLength‬ﺗﺤـﺪد‬
‫اﻟﻌﺪد اﻻﻗﺼﻰ ﻣﻦ اﻟﺤﺮوف اﻟﺘﻲ ﻳﻤﻜﻦ ان ﻳﻜﺘﺒﻬﺎ اﻟﻤﺴﺘﺨﺪم. ﺗﺴـﺘﻄﻴﻊ ﺗﺤﺪﻳـﺪ ﺣـﺮف‬
‫ﻣﻌــﻴﻦ آﺎﻟﻨﺠﻤــﺔ "*" ﻟﺘﻈﻬــﺮ ﺑﻤﻘــﺪار ﻋــﺪد اﻟﺤــﺮوف اﻟﻤﻜﺘﻮﺑــﺔ ﻋــﻦ ﻃﺮﻳــﻖ اﻟﺨﺎﺻــﻴﺔ‬
                   ‫‪ ،PasswordChar‬وﻣﻦ اﻟﻮاﺿﺢ ان اﻟﻐﺮض اﻟﺮﺋﻴﺲ ﻟﻬﺎ ﻟﻜﻠﻤﺎت اﻟﺴﺮ.‬

 ‫اذا اﺳﺘﺨﺪﻣﺖ اﻟﺨﺎﺻﻴﺔ ‪ ،PasswordChar‬ﻓﺎن اﻟﻤﺴﺘﺨﺪم ﻟﻦ ﻳـﺘﻤﻜﻦ‬                ‫ﻣﻼﺣﻈﺔ:‬
 ‫ﻣﻦ ﺳﺮﻗﺔ اﻟﻨﺺ اﻟﻤﻜﺘﻮب ﻋﻠﻰ اﻷداة ﺑﺎﺧﺘﻴﺎر اﻻﻣﺮ ‪ Copy‬ﻣﻦ اﻟﻘﺎﺋﻤﺔ‬
 ‫اﻟﻤﻨﺴﺪﻟﺔ ﺑﻌﺪ اﻟﻨﻘـﺮ ﺑـﺰر اﻟﻔـﺄرة اﻻﻳﻤـﻦ ﻋﻠـﻰ أداة اﻟـﻨﺺ، ﻷن ذاآـﺮة‬
 ‫‪ Visual Basic‬ﻻ ﺗﻨﺴــﻰ اﻟﻐــﺎء اواﻣــﺮ اﻟﻨﺴــﺦ واﻟﻘــﺺ ﻣــﻦ اﻟﻘﺎﺋﻤــﺔ‬
 ‫اﻟﺴﺎﺑﻘﺔ. اﻣﺎ ﻟﻮ اﻧﺸﺄت ﻗﻮاﺋﻢ ﺑﻬﺎ اواﻣﺮ ﻧﺴـﺦ وﻟﺼـﻖ، ﻓـﺬاآﺮﺗﻚ هـﻲ‬
                     ‫اﻟﻤﺴﺆوﻟﺔ ﻋﻦ اﻟﻐﺎء او ﻋﺪم ﺗﻤﻜﻴﻦ هﺬﻩ اﻟﻮﻇﺎﺋﻒ.‬
                                              ‫55‬


‫اﺳﺘﺨﺪم اﻟﺨﺎﺻﻴﺔ ‪ MultiLine‬ﻟﺘﻤﻜﻦ اﻟﻤﺴﺘﺨﺪم ﻣﻦ ﺗﺤﺮﻳﺮ اﻟﻨﺺ ﻋﻠﻰ ﻋـﺪة ﺳـﻄﻮر،‬
       ‫وﻻ ﺗﻨﺴﻰ اﻟﺨﺎﺻﻴﺔ ‪ ScorllBars‬ﻓﻬﻲ ﺗﺘﺤﻜﻢ ﺑﻈﻬﻮر او اﺧﻔﺎء اﺷﺮﻃﺔ اﻟﺘﻤﺮﻳﺮ.‬

 ‫اذا آﺎﻧــﺖ ﻗﻴﻤــﺔ اﻟﺨﺎﺻــﻴﺔ ‪ MultiLine‬هــﻲ ‪ True‬وﻗﻴﻤــﺔ اﻟﺨﺎﺻــﻴﺔ‬     ‫ﻣﻼﺣﻈﺔ:‬
 ‫‪ ScorllBars‬هــﻲ ‪ 0-None‬او ‪ ،2-Vertical‬ﻓــﺎن اﻟــﻨﺺ اﻟــﺬي ﻳﻜﺘﺒــﻪ‬
 ‫اﻟﻤﺴﺘﺨﺪم ﺳﻴﺘﻢ ازاﺣﺘﻪ اﻟﻰ ﺳﻄﺮ ﺟﺪﻳﺪ ﺑﻤﺠﺮد اﻟﻮﺻﻮل اﻟﻰ ﺣـﺪود‬
                          ‫اﻻداة –آﺎﻟﺨﺎﺻﻴﺔ ‪ WordWrap‬ﻻداة اﻟﻌﻨﻮان.‬

‫ﻣﻦ ﺧﺼﺎﺋﺺ وﻗﺖ اﻟﺘﻨﻔﻴﺬ ‪ Run Time Properties‬اﻟﺘﺎﺑﻌـﺔ ﻻداة اﻟـﻨﺺ هـﻲ ﺧﺼـﺎﺋﺺ‬
‫ﺗﻤﻜﻨﻚ ﻣﻦ ﺗﺤﺪﻳﺪ ﻧﺺ ﻣﻌﻴﻦ، ﺣﻴﺚ ﺗﻀﻊ ﻧﻘﻄﺔ اﻟﺒﺪاﻳﺔ ﻓـﻲ اﻟﺨﺎﺻـﻴﺔ ‪ SelStart‬وﻃـﻮل‬
‫اﻟﺘﺤﺪﻳﺪ ﻓﻲ اﻟﺨﺎﺻﻴﺔ ‪ .SelLength‬اﻟﻜـﻮد اﻟﺘـﺎﻟﻲ ﻳﻘـﻮم ﺑﺘﺤﺪﻳـﺪ اﻟـﻨﺺ ﺑﻤﺠـﺮد اﻧﺘﻘـﺎل‬
                                                            ‫اﻟﺘﺮآﻴﺰ اﻟﻰ أداة اﻟﻨﺺ:‬

‫)(‪Private Sub Text1_GotFocus‬‬
   ‫0 = ‪Text1.SelStart‬‬
   ‫)‪Text1.SelLength = Len(Text1.Text‬‬
‫‪End Sub‬‬

‫واذا اردت ﻣﻌﺮﻓﺔ او اﺳﺘﺒﺪال اﻟﻨﺺ اﻟﻤﺤﺪد ﻓﺎﺳﺘﺨﺪم اﻟﺨﺎﺻﻴﺔ ‪ .SelText‬اﻣﺎ اﻟﺨﺎﺻﻴﺔ‬
‫‪ Text‬ﻓﻬﻲ ﺗﻤﺜﻞ آﺎﻣﻞ اﻟﻨﺺ اﻟﻤﻮﺟﻮد ﻓـﻲ اﻻداة ﺳـﻮاء آـﺎن ﻣﺤـﺪدا او ﻻ، ﻓﻠـﻮ اردت‬
               ‫اﺿﺎﻓﺔ ﻧﺺ اﻟﻰ اﻻداة دون ﺣﺬف اﻟﻨﺺ اﻟﻤﻮﺟﻮد ﺑﻬﺎ ﻓﺎآﺘﺐ ﺷﻴﺌﺎ ﻣﺜﻞ:‬

‫”ﻧﺺ اﺿﺎﻓﻲ“ = ‪Text1.SelText‬‬

‫ﻣﻦ اﻟﻀﺮوري اﻟﺘﻨﻮﻳـﻪ هﻨـﺎ ﺑـﺎن اﻟﻤﺴـﺘﺨﺪم ﻟـﻦ ﻳﺴـﺘﻄﻴﻊ اﺳـﺘﺨﺪام ﻣﻔﺘـﺎح اﻟﺠﺪوﻟـﺔ‬
‫]‪ [TAB‬اﺛﻨﺎء اﻟﻜﺘﺎﺑﺔ ﻓﻲ ﺧﺎﻧﺔ اﻟـﻨﺺ، واﻟﺴـﺒﺐ ﻓـﻲ ذﻟـﻚ ﻣﻨﻄﻘـﻲ، ﻓﺎﻟﻤﻔﺘـﺎح ]‪[TAB‬‬
‫ﻳﺆدي اﻟﻰ اﻧﺘﻘﺎل اﻟﺘﺮآﻴﺰ اﻟﻰ اﻻدوات اﻻﺧﺮى، ﺗﺴﺘﻄﻴﻊ اﻟﻠﺘﻔﺎف ﺣﻮل هﺬﻩ اﻟﻤﺸـﻜﻠﺔ‬
                 ‫اﻟﺒﺴﻴﻄﺔ ﺑﺎﻟﻐﺎء اﻟﺨﺎﺻﻴﺔ ‪ TabStop‬ﻟﺠﻤﻴﻊ اﻻدوات وﻣﻦ ﺛﻢ اﻋﺎدﺗﻬﺎ:‬

‫)(‪Private Sub Text1_GotFocus‬‬
   ‫‪On Error Resume Next‬‬
   ‫‪Dim ctrl As Control‬‬

  ‫‪For Each ctrl In Controls‬‬
     ‫‪ctrl.TabStop = False‬‬
                                                  ‫65‬


  ‫‪Next‬‬
  ‫‪Err.Clear‬‬
‫‪End Sub‬‬

‫)(‪Private Sub Text1_LostFocus‬‬
   ‫‪On Error Resume Next‬‬
   ‫‪Dim ctrl As Control‬‬

  ‫‪For Each ctrl In Controls‬‬
     ‫‪ctrl.TabStop = True‬‬
  ‫‪Next‬‬
  ‫‪Err.Clear‬‬
‫‪End Sub‬‬

‫ﻣﻦ اﻟﻤﺸﺎآﻞ اﻟﺘﻲ ﺗﻮاﺟﻪ ﻣﺴﺘﺨﺪﻣﻲ ‪ Windows 2000, XP‬اﻟﻌﺮب هﻲ ﻋـﺪم ﻇﻬـﻮر‬
‫اﻟﺤﺮوف اﻟﻌﺮﺑﻴﺔ ﺑﺎﻟﺸﻜﻞ اﻟﻤﻄﻠﻮب –اﺣﻴﺎﻧﺎ- ﻋﻨﺪ ﻧﺴﺨﻬﺎ ﻣﻦ أداة اﻟﻨﺺ واﻟﺼـﺎﻗﻬﺎ اﻟـﻰ‬
‫ﺑﺮﻧــﺎﻣﺞ ﺁﺧــﺮ، واﻟﺴــﺒﺐ ﻓــﻲ ذﻟــﻚ ﻳﺘﻌﻠــﻖ ﺑﺘﻮزﻳــﻊ ﺻــﻔﺤﺎت اﻟﻤﺤــﺎرف اﻟﺘﺎﺑﻌــﺔ ﻟﺘﺮﻣﻴــﺰ‬
‫‪ UNICODE‬ﻻن ﺗﺮﻣﻴﺰ أدوات ‪ Visual Basic‬ﻣﺎ زال ﻣﺒﻨـﻲ ﻋﻠـﻰ ﺟـﺪول ‪ ،ASCII‬ﻻ ارﻳـﺪ‬
   ‫ـ‬         ‫ـ‬       ‫ـ‬      ‫ـ‬
‫ان اﻓﺼ ـﻞ ﻓ ـﻲ اﻟﻤﻮﺿ ـﻮع اآﺜ ـﺮ ﻣ ـﻦ ذﻟ ـﻚ ﺣﺘ ـﻰ ﻻ ﻧﺨ ـﺮج ﻋ ـﻦ ﻣﺠ ـﺎل اﻟﻔﻘ ـﺮة، وﻟﻜﻨ ـﻚ‬
                                  ‫ـ‬        ‫ـ‬     ‫ـ‬     ‫ـ ـ‬        ‫ـ‬        ‫ـ ـ‬
‫ﺗﺴﺘﻄﻴﻊ ﺣﻞ هـﺬﻩ اﻟﻤﺸـﻜﻠﺔ ﺑﺘﻐﻴﻴـﺮ اﻟﻠﻐـﺔ اﻟـﻰ اﻟﻠﻐـﺔ اﻟﻌﺮﺑﻴـﺔ ﺑﺎﻟﻀـﻐﻂ ﻋﻠـﻰ اﻻزرار‬
                         ‫]‪ [Alt+SHIFT‬او ﻋﻤﻞ ذﻟﻚ ﺑﺮﻣﺠﻴﺎ ﻗﺒﻞ ﻋﻤﻠﻴﺔ اﻟﻨﺴﺦ او اﻟﻘﺺ:‬

‫_ ‪Declare Function LoadKeyboardLayout Lib "user32" Alias‬‬
‫_ ‪"LoadKeyboardLayoutA" (ByVal pwszKLID As String, ByVal‬‬
‫‪flags As Long) As Long‬‬

‫)(‪Sub BeforeCopyOrCut‬‬
  ‫1 ,"10400000" ‪LoadKeyboardLayout‬‬
‫‪End Sub‬‬

                                                           ‫اﻟﺴﻴﻄﺮة ﻋﻠﻰ اﻟﻤﺪﺧﻼت:‬
‫اﻟﻤﺸــﻜﻠﺔ اﻟﺘــﻲ اود ان اوﺿــﺤﻬﺎ هــﻮ اﻧﻨــﺎ ﺣــﻴﻦ ﻧﺒــﺮﻣﺞ ﻧﺘﻮﻗــﻊ ادﺧــﺎﻻت ﻣﻌﻴﻨــﺔ ﻣــﻦ‬
‫اﻟﻤﺴﺘﺨﺪم. ﻓﻤﺜﻼ، وﺿـﻌﺖ أداة ﻧـﺺ ﻟﺘﺠﻌـﻞ اﻟﻤﺴـﺘﺨﺪم ﻳﻜﺘـﺐ ﻋﻤـﺮﻩ ﻓﺒﻜـﻞ ﺗﺄآﻴـﺪ‬
‫ﺳﺘﺘﻮﻗﻊ ان ﻳﻜﻮن اﻟﻌﻤﺮ ﻗﻴﻤﺔ ﻋﺪدﻳﺔ، ﻟﻜﻦ ﻣﺎذا ﻟﻮ ادﺧﻞ اﻟﻤﺴﺘﺨﺪم ﺣﺮوﻓﺎ؟ ﻓﺎﻧﻪ ﻣـﻦ‬
‫اﻟﻤﺆآﺪ أن ﻣﻨﻄﻖ ﺳﻴﺮ وﺳﻠﻮك ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺳﻴﺘﺄﺛﺮ ﻓﻲ اﻓﻀﻞ اﻻﺣـﻮال هـﺬا اذا ﻟـﻢ‬
‫ﺗﻈﻬﺮ رﺳﺎﻟﺔ اﻟﺨﻄﺄ ‪ .Run Time Error‬ﻟﺬﻟﻚ ﺳﺘﻀﻄﺮ ﻟﻜﺘﺎﺑﺔ اآﻮاد اﺿـﺎﻓﻴﺔ ﻟﺘﻀـﻤﻦ ان‬
                                            ‫75‬


‫أداة اﻟﻨﺺ ﻻ ﺗﺤﺘﻮي اﻻ ﻋﻠﻰ اﻋﺪاد، وﻟﻌﻞ اﻟﺤﺪث اﻟﻤﻨﺎﺳﺐ ﻟﻜﺘﺎﺑـﺔ آـﻮد اﻟﺘﺤﻘـﻖ هـﻮ‬
                                                           ‫ﺣﺪث ‪:KeyPress‬‬

‫)‪Private Sub Text1_KeyPress (KeyAscii As Integer‬‬
  ‫‪If KeyAscii < 48 Or KeyAscii > 57 Then‬‬
     ‫اﻟﻤﻔﺘﺎح اﻟﻤﺪﺧﻞ ﻟﻴﺲ ﻋﺪد ‘‬
     ‫0 = ‪KeyAscii‬‬
  ‫‪End If‬‬
‫‪End Sub‬‬

‫ﻣﻬﻼ ﻣﻬﻼ اﺧﻲ اﻟﻜـﺮﻳﻢ، ﻋـﺎﻟﻢ اﻟﺒﺮﻣﺠـﺔ ﻟﻌﺒـﺔ ﻋﻘﻠﻴـﺔ وﻣﻨﻄﻘﻴـﺔ، واﻻﻣـﻮر ﻓﻴـﻪ ﻻ ﺗـﺘﻢ‬
‫ﺑﺎﻟﺴﻬﻮﻟﺔ اﻟﺘﻲ ﺗﺘﻮﻗﻌﻬﺎ! ﻻﻧﻪ ﻣﺎ زاﻟـﺖ هﻨﺎﻟـﻚ اﻣﻜﺎﻧﻴـﺔ ان ﻳـﺪﺧﻞ اﻟﻤﺴـﺘﺨﺪم ﺣـﺮوف‬
‫ﻓﻲ أداة اﻟﻨﺺ وهﻲ ﺑﺎﺧﺘﺼﺎر: ﻋﻦ ﻃﺮﻳﻖ ﻟﺼﻖ ﻗﻴﻢ ﺣﺮﻓﻴﺔ ﻣـﻦ اﻟﺤﺎﻓﻈـﺔ أي ﺑﺎﻟﻀـﻐﻂ‬
‫ﻋﻠﻰ اﻟﻤﻔﺘﺎﺣﻴﻦ ‪ .Ctrl + V‬ﻓـﻮرا ﺳـﺘﻜﻮن اﺟﺎﺑﺘـﻚ اﻟﺬآﻴـﺔ ﺟـﺪا هـﻲ ان ﻧﻜﺘـﺐ اآـﻮاد‬
‫اﺿﺎﻓﻴﺔ ﻓﻲ ﺣﺪث ‪ KeyDown‬ﻧﻤﻨﻊ ﻓﻴـﻪ اﻟﻤﺴـﺘﺨﺪم ﻣـﻦ اﺟـﺮاء ﻋﻤﻠﻴـﺔ اﻟﻠﺼـﻖ. ﺻـﺢ‬
‫ﻟﺴﺎﻧﻚ! ﻟﻜﻨﻚ ﻧﺴﻴﺖ ﻃﺮﻳﻘﺔ اﺧﺮى ﻟﻠﺼﻖ وهﻲ ﻋﻦ ﻃﺮﻳﻖ اﻟﻘﺎﺋﻤـﺔ اﻟﻤﺨﺘﺼـﺮة اﻟﺘـﻲ‬
‫ﻳﻀﻴﻔﻬﺎ ‪ Visual Basic‬اﻟﻰ أداة اﻟﻨﺺ واﻟﺘﻲ ﺗﻈﻬﺮ ﻋﻦ ﻃﺮﻳﻖ زر اﻟﻔﺄرة اﻻﻳﻤـﻦ، واﻟﺘـﻲ‬
                                ‫ﻣﻦ ﺧﻼﻟﻬﺎ ﻳﺴﺘﻄﻴﻊ اﻟﻤﺴﺘﺨﺪم ان ﻳﻠﺼﻖ اﻟﻨﺼﻮص!‬
‫ﻻ ﺗﻮﺟﺪ ﻣﺸﻜﻠﺔ اﻻ وﻟﻬﺎ ﺣﻞ ﻓﻬﺬا ﻋﺎﻟﻢ اﻟﺒﺮﻣﺠﺔ ﻣﺸـﺎآﻞ وﺣﻠـﻮل. ﻣـﻦ وﺟﻬـﺔ ﻧﻈـﺮي‬
‫اﻟﺸﺨﺼﻴﺔ، ارى ان اﻓﻀﻞ ﻣﻜﺎن -اﻗﺼﺪ ﺣﺪث- ﻟﻠﺘﺤﻘﻖ ﻣﻦ ﻧـﻮع ﻗﻴﻤـﺔ اﻟـﻨﺺ اﻟﻤـﺪﺧﻞ‬
‫هﻮ اﻟﺤﺪث ‪ ،Change‬ﻟﻜﻦ اﻟﻤﺸﻜﻠﺔ ﻓﻴﻪ اﻧﻪ ﻳﺘﻄﻠـﺐ ﺗﺼـﺮﻳﺢ ﻣﺘﻐﻴـﺮﻳﻦ ﻋـﺎﻣﻴﻦ ﻟﻠﻌـﻮدة‬
                ‫ﺑﺎﻟﻘﻴﻤﺔ اﻟﻘﺪﻳﻤﺔ ﻷداة اﻟﻨﺺ اذا آﺎﻧﺖ اﻟﻘﻴﻤﺔ اﻟﺠﺪﻳﺪة ﻟﻴﺴﺖ ﻋﺪدﻳﺔ:‬

‫‪Dim OldText As String‬‬
‫‪Dim OldSelStart As Long‬‬

‫)(‪Private Sub Text1_GotFocus‬‬
‫ﻋﻨﺪﻣﺎ ﻳﻜﻮن اﻟﺘﺮآﻴﺰ ﻋﻠﻰ اﻻداة ‘‬
‫ﻻﺑﺪ ﻣﻦ ﺣﻔﻆ ﻗﻴﻤﺘﻬﺎ ‘‬
   ‫‪OldText = Text1.Text‬‬
   ‫‪OldSelStart = Text1.SelStart‬‬
‫‪End Sub‬‬

‫)(‪Private Sub Text1_Change‬‬
   ‫‪If Not IsNumeric(Text1.Text) Then‬‬
‫اﻟﻤﻔﺘﺎح اﻟﻤﺪﺧﻞ ﻟﻴﺲ رﻗﻢ ‘‬
                                              ‫85‬


‫ﻗﻢ ﺑﺎﻋﺎدة ﻋﺮض اﻟﻘﻴﻤﺔ اﻟﻘﺪﻳﻤﺔ ‘‬
      ‫ﺗﻮﺟﺪ ﻣﺸﻜﻠﺔ ﺧﻄﻴﺮة هﻨﺎ ‘ ‪Text1.Text = OldText‬‬
      ‫‪Text1.SelStart = OldSelStart‬‬
   ‫‪Else‬‬
‫اﻟﻘﻴﻤﺔ اﻟﻤﺪﺧﻠﺔ رﻗﻤﻴﺔ اذا ‘‬
‫ﻗﻢ ﺑﺤﻔﻈﻬﺎ ‘‬
      ‫‪OldText = Text1.Text‬‬
      ‫‪OldSelStart = Text1.SelStart‬‬
   ‫‪End If‬‬
‫‪End Sub‬‬

‫آﻤﺎ ﺗﻼﺣﻆ، ﻓﻲ اﻟﻜﻮد اﻟﺴﺎﺑﻖ ﻟﻚ ﻣﻨﻲ ﺿﻤﺎن ان اﻟﻤﺴﺘﺨﺪم ﻟﻦ ﻳﺴﺘﻄﻴﻊ ادﺧـﺎل اﻻ‬
‫اﻻرﻗﺎم ﻟﻜﻦ ﻓﻲ اﺣﺪ اﻟﺴﻄﻮر آﺘﺒﺖ اﻟﺘﻌﻠﻴﻖ "ﺗﻮﺟﺪ ﻣﺸﻜﻠﺔ ﺧﻄﻴﺮة هﻨﺎ" واﻟﺴﺒﺐ اﻧﻪ‬
‫ﻋﻨـﺪﻣﺎ ﻳـﺘﻢ ﺗﻨﻔﻴـﺬ اﻟﺴـﻄﺮ ‪ ،Text1.Text = OldText‬ﺳـﻴﻘﻮم ‪ Visual Basic‬ﺑﺘﻨﻔﻴـﺬ‬
‫اﻻﺟﺮاء ‪ Text1_Change‬ﻣﻦ ﺟﺪﻳﺪ! أي ان هﺬا اﻻﺟﺮاء ﺳﻴﺘﻢ ﺗﻨﻔﻴﺬﻩ آﻤـﺎ ﻳﻌـﺮف ﻓـﻲ‬
‫ﻋــﺎﻟﻢ اﻟﺒﺮﻣﺠــﺔ ﺗﺮاﺟﻌــﻲ ‪ Recursivly‬وهــﻮ اﺣــﺪ اﺳــﺎﻟﻴﺐ اﻟﺨﻮارزﻣﻴــﺎت اﻟﺘﺮاﺟﻌﻴــﺔ‬
‫‪ .Recursion‬وﺣﺘﻰ ﺗﺘﻔﺎدى هﺬﻩ اﻟﻤﺸﻜﻠﺔ اﺳـﺘﺨﺪم ﻣﺘﻐﻴـﺮ ﺳـﺘﺎﺗﻴﻜﻲ ﻳﻤﻨـﻊ ﺣـﺪوث‬
                                                                              ‫ذﻟﻚ:‬

‫)(‪Private Sub Text1_Change‬‬
‫ﻣﺘﻐﻴﺮ ﻳﻤﻨﻊ اﺳﺘﺪﻋﺎء اﻻﺟﺮاء ﺗﺮاﺟﻌﻴﺎ ‘‬
   ‫‪Static bExitNow As Boolean‬‬
   ‫‪If bExitNow Then Exit Sub‬‬

   ‫‪If Not IsNumeric(Text1.Text) Then‬‬
‫اﻟﻤﻔﺘﺎح اﻟﻤﺪﺧﻞ ﻟﻴﺲ رﻗﻢ ‘‬
‫ﻗﻢ ﺑﺎﻋﺎدة ﻋﺮض اﻟﻘﻴﻤﺔ اﻟﻘﺪﻳﻤﺔ ‘‬
      ‫‪bExitNow = True‬‬
      ‫ذهﺒﺖ اﻟﻤﺸﻜﻠﺔ اﻟﺨﻄﻴﺮة اﻟﺘﻲ آﺎﻧﺖ هﻨﺎ ‘ ‪Text1.Text = OldText‬‬
      ‫‪bExitNow = False‬‬
      ‫‪Text1.SelStart = OldSelStart‬‬
   ‫‪Else‬‬
‫اﻟﻘﻴﻤﺔ اﻟﻤﺪﺧﻠﺔ رﻗﻤﻴﺔ اذا ‘‬
‫ﻗﻢ ﺑﺤﻔﻈﻬﺎ ‘‬
      ‫‪OldText = Text1.Text‬‬
      ‫‪OldSelStart = Text1.SelStart‬‬
                                               ‫95‬


  ‫‪End If‬‬
‫‪End Sub‬‬

‫ﻣﺎزاﻟﺖ ﺗﻮﺟﺪ ﻣﺸﻜﻠﺔ اﺧﺮى وﺧﻄﻴﺮة اﻳﻀﺎ! وهﻲ ﺗﺘﻌﻠﻖ ﺑﻤﻮﻗﻊ اﻟﻤﺆﺷﺮ ‪ Caret‬اﻟﺨﺎص‬
‫ﺑﺄداة اﻟﻨﺺ. ﻓﺎﻟﻜﻮد اﻟﺴﺎﺑﻖ ﻻ ﻳﻘﻮم ﺑﺤﻔﻆ ﻣﻮﻗﻊ اﻟﻤﺆﺷـﺮ اﻻ ﻓـﻲ ﺣﺎﻟـﺔ ﺗﻐﻴﻴـﺮ اﻟﻘﻴﻤـﺔ‬
‫ﻷداة اﻟﻨﺺ ﻣﻤﺎ ﻳﺘﺴﺒﺐ ﻓـﻲ ﻣﺸـﺎآﻞ ﻻ ﻧﻬﺎﻳـﺔ ﻟﻬـﺎ ﻋﻨـﺪﻣﺎ ﻳﻘـﻮم اﻟﻤﺴـﺘﺨﺪم ﺑﺘﻐﻴﻴـﺮ‬
‫ﻣﻜﺎن اﻟﻤﺆﺷﺮ دون ﺗﻐﻴﻴﺮ اﻟﻘﻴﻤﺔ آﺘﺤﺮﻳﻜﻪ ﺑﻼﺳﻬﻢ ﻓﻲ ﻟﻮﺣﺔ اﻟﻤﻔـﺎﺗﻴﺢ او ﺑـﺰر اﻟﻔـﺄرة.‬
                      ‫واﻟﺤﻞ ﻋﻦ ﻃﺮﻳﻖ ﺣﻔﻆ ﻗﻴﻤﺔ ﻣﻮﻗﻊ اﻟﻤﺆﺷﺮ ﻓﻲ ﺣﺎﻟﺔ ﺣﺪوث ذﻟﻚ:‬

‫)‪Private Sub Text1_KeyUp (KeyCode As Integer, Shift As Integer‬‬
  ‫‪OldSelStart = Text1.SelStart‬‬
‫‪End Sub‬‬

‫_ ,‪Private Sub Text1_MouseUp (Button As Integer, Shift As Integer‬‬
              ‫)‪X As Single, Y As Single‬‬
  ‫‪OldSelStart = Text1.SelStart‬‬
‫‪End Sub‬‬

‫)‪Private Sub Text1_KeyDown (KeyCode As Integer, Shift As Integer‬‬
  ‫‪OldSelStart = Text1.SelStart‬‬
‫‪End Sub‬‬

‫)(‪Private Sub Text1_Click‬‬
  ‫‪OldSelStart = Text1.SelStart‬‬
‫‪End Sub‬‬

‫آﻤﺎ ﻳﻘﻮل اﺧﻮاﻧﻨﺎ اﻻﻋﺰاء ﻓﻲ ﻣﺼﺮ: دي ﻟﻮ ﻋﻠﻰ ﺟﻮﺳﺘﻲ، اﻟﻴﻮزر ﻣـﺶ ﺣﺎﻳﺌـﺪر ﻳﻜﺘـﺐ‬
‫ﺣﺎﺟﻪ ﻏﻴﺮ ﻧﻤﺮﻩ! ﻟﻜﻦ ﻣـﻦ ﻧﺎﺣﻴـﺔ ﻋﻘﻠﻴـﺔ هـﻞ ﻣـﻦ اﻟﻤﻌﻘـﻮل اﻧـﻚ ﺳـﺘﻜﺘﺐ آـﻞ هـﺬﻩ‬
   ‫اﻻآﻮاد، آﻠﻤﺎ اﺣﺘﺠﺖ اﻟﺘﺤﻘﻖ ﻣﻦ ان اﻟﻤﺴﺘﺨﺪم ﻗﺎم ﺑﺎدﺧﺎل ارﻗﺎم ﻓﻲ أداة اﻟﻨﺺ!؟‬
‫ﺑﻜﻞ ﺗﺄآﻴﺪ ﻟﻮ ﻟﻢ ﻳﻜﻦ هﻨﺎك ﺣﻞ ﺁﺧﺮ ﻟﻤﺎ آﻨﺖ ﻗﺪ ﻋﺮﺿـﺖ اﻟﻤﺸـﻜﻠﺔ ﻣـﻦ اﻟﺒﺪاﻳـﺔ، ﻻن‬
‫اﻟﺤﻞ ﻳﺘﻢ ﺑﺎﺧﺘﺒﺎر اﻟﻘﻴﻤﺔ ﺑﻌﺪ ان ﻳﻨﺘﻬﻲ اﻟﻤﺴﺘﺨﺪم ﻣﻦ ادﺧﺎل اﻟﻘﻴﻤﺔ وﻟﻴﺲ ﻓﻲ اﺛﻨﺎء‬
‫ذﻟﻚ. وﻳﺘﻢ ذﻟﻚ ﻋﻦ ﻃﺮﻳﻖ اﻟﺤﺪث ‪ Validate‬اﻟﺬي ﻇﻬﺮ آﺤﻞ ﻟﻤﺒﺮﻣﺠـﻲ ‪Visual Basic‬‬
‫ﻟﻤﻮاﺟﻬﺔ ﻣﺜﻞ هﺬﻩ اﻟﻤﺸﺎآﻞ ﺑﺎﻟﺘﺤﺪﻳﺪ ﻣﻊ اﺻـﺪارﻩ اﻟﺴـﺎدس. ﺣـﺪث ‪ Validate‬ﻳﻌﻤـﻞ‬
‫ﺑﺎﻟﺘﻜﺎﻣــﻞ ﻣــﻊ اﻟﺨﺎﺻــﻴﺔ ‪ ،CausesValidation‬ﻟﻤﻌﺮﻓــﺔ آﻴــﻒ ﻳــﺘﻢ ذﻟــﻚ، راﻗــﺐ هــﺬا‬
‫اﻟﺴﻴﻨﺎرﻳﻮ: ﻋﻨﺪﻣﺎ ﻳﻨﺘﻘﻞ اﻟﺘﺮآﻴﺰ ﻣﻦ أدا اﻟﻨﺺ 1‪ Text‬اﻟﻰ اﻻداة ‪ ،X‬ﻳﻘﻮم ‪Visual Basic‬‬
‫ﺑﺎﺧﺘﺒﺎر ﻗﻴﻤﺔ اﻟﺨﺎﺻﻴﺔ ‪ CausesValidation‬اﻟﺘﺎﺑﻌﺔ ﻟـﻼداة ‪ ،X‬واذا آﺎﻧـﺖ ﻗﻴﻤﺘﻬـﺎ ‪،True‬‬
                                                 ‫06‬


‫ﻳﻘﻮم ‪ Visual Basic‬ﺑﺘﻨﻔﻴﺬ اﻟﺤﺪث ‪ Validate‬اﻟﺘـﺎﺑﻊ ﻷدا اﻟـﻨﺺ 1‪ Text‬ﻣﻌﻄﻴـﺎ اﻟﻤﺒـﺮﻣﺞ‬
               ‫ﻓﺮﺻﺔ ﻻﺧﺘﺒﺎر ﻧﻮع اﻟﻘﻴﻤﺔ. ﻓﺘﺴﺘﻄﻴﻊ اﺧﺘﺼﺎر هﺬﻩ اﻟﻤﻘﺎﻟﺔ ﺑﻬﺬا اﻟﻜﻮد:‬

‫)‪Private Sub Text1_Validate(Cancel As Boolean‬‬
   ‫‪If Not IsNumeric(Text1.Text) Then‬‬
‫اﻟﻤﻔﺘﺎح اﻟﻤﺪﺧﻞ ﻟﻴﺲ رﻗﻢ ‘‬
      ‫‪Cancel = True‬‬
   ‫‪End If‬‬
‫‪End Sub‬‬

‫ﻓﺘﻼﺣﻆ اﻧﻨﺎ ﻗﻤﻨﺎ ﺑﺘﻐﻴﻴﺮ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪ Cancel‬اﻟﻰ ‪ True‬ﺣﺘﻰ ﻧﻠﻐﻲ ﻋﻤﻠﻴـﺔ اﻻدﺧـﺎل‬
‫ﻣﻦ اﻟﻤﺴﺘﺨﺪم وﻧﻌﻮد ﺑﺎﻟﺘﺮآﻴﺰ اﻟﻰ أدا اﻟﻨﺺ 1‪ .Text‬وﻗﺪ ﻳﺴﺄل ﺳﺎﺋﻞ وﻳﻘﻮل ﻟﻤـﺎذا ﻻ‬
‫ﻧﺴﺘﺨﺪم اﻟﺤﺪث ‪ LostFocus‬ﺑﺪﻻ ﻣﻦ ‪Validate‬؟ واﻟﺠﻮاب هـﻮ ان اﻟﺤـﺪث ‪LostFocus‬‬
‫ﻏﻴﺮ ﻣﺮن! أي اﻧﻚ ﺗﺤﺘﺎج اﻟﻰ اآـﻮاد اﺿـﺎﻓﻴﺔ ﻟﺘﻌـﺪﻳﻞ اﻟﺨﻴـﺎرات )ﻓـﻼ ﻳﻮﺟـﺪ ﺑـﻪ اﻟﻤﺘﻐﻴـﺮ‬
‫‪ (Cancel‬اﻟﻤﺰﻳﺪ اﻳﻀﺎ، اﻟﺤﺪث ‪ LostFocus‬ﺳﻴﻘﻮم داﺋﻤﺎ ﺑﺎﺧﺘﺒﺎر اﻟﻘﻴﻤﺔ رﻏﻢ اﻧﻚ ﻻ ﺗﻮد‬
‫اﺧﺘﺒﺎر اﻟﻘﻴﻤـﺔ داﺋﻤـﺎ، ﻣـﺜﻼ ﻋﻨـﺪﻣﺎ ﻳﻘـﻮم اﻟﻤﺴـﺘﺨﺪم ﺑﺎﻟﻀـﻐﻂ ﻋﻠـﻰ اﻟـﺰر اﻟﻐـﺎء اﻻﻣـﺮ‬
                                       ‫‪ Cancel‬اﻟﺨﺎص ﺑﺼﻨﺪوق اﻟﺤﻮار اﻟﺬي ﺻﻤﻤﺘﻪ.‬

                                            ‫زر اﻻواﻣﺮ ‪CommandButton‬‬
 ‫ـ‬                                ‫ـ‬               ‫ـ‬
‫ﺑﻌ ـﺪ اداﺗ ـﻲ اﻟﻌﻨ ـﻮان واﻟ ـﻨﺺ ﺗﺒ ـﺪأ ﺑﺎﺳ ـﺘﺨﺪام زر اﻻواﻣ ـﺮ ‪ .CommandButton‬ﻻ ﻳﻮﺟ ـﺪ‬
                                                          ‫ـ‬    ‫ـ‬     ‫ـ‬       ‫ـ‬      ‫ـ‬
‫اﻟﻜﺜﻴﺮ ﻻﺧﺒﺮك ﺑـﻪ ﻋﻨﻬـﺎ اﻻ اﻟﺨﺎﺻـﻴﺘﺎن ‪ Default‬و ‪ ،Cancel‬اﻻوﻟـﻰ ﺗﻀـﻊ ﺣـﺪ اﺿـﺎﻓﻲ‬
‫ﺣــﻮل اﻟــﺰر ﺗﻤﻜــﻦ اﻟﻤﺴــﺘﺨﺪم ﻣــﻦ ﺗﻨﻔﻴــﺬ زر اﻻواﻣــﺮ ﺑﻤﺠــﺮد اﻟﻀــﻐﻂ ﻋﻠــﻰ اﻟﻤﻔﺘــﺎح‬
‫]‪ [ENTER‬واﻟﺜﺎﻧﻴــﺔ ﻣﺮاﻓﻘــﺔ ﻟﻠﻤﻔﺘــﺎح ]‪ .[ESC‬وﺑﺎﻟﻨﺴــﺒﺔ ﻟﺨﺼــﺎﺋﺺ اﻟﺼــﻮر ‪،Picture‬‬
‫‪ DisablePicture‬و ‪ DownPicture‬ﻓﻠــﻦ ﺗــﺘﻤﻜﻦ ﻣــﻦ رؤﻳــﺔ ﻧﺘﺎﺋﺠﻬــﺎ ﺣﺘــﻰ ﺗﻐﻴــﺮ ﻗﻴﻤــﺔ‬
                                                       ‫اﻟﺨﺎﺻﻴﺔ ‪ Style‬اﻟﻰ ‪.1-Graphical‬‬

 ‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﺨﺎﺻﻴﺔ ‪ Caption‬ﻓﻬﻲ ﺗﺘﺄﺛﺮ ﺑﺎﻟﺮﻣﺰ "&" داﺋﻤﺎ آﻤﺎ ﺗﺘـﺄﺛﺮ أداة‬        ‫ﻣﻼﺣﻈﺔ:‬
 ‫اﻟﻌﻨﻮان ‪ Label‬ﺑﻬﺬا اﻟﺮﻣﺰ ﻋﻨﺪﻣﺎ ﺗﻜﻮن ﻗﻴﻤﺔ ﺧﺎﺻـﻴﺘﻬﺎ ‪UseMnemonic‬‬
                                                      ‫ﺗﺴﺎوي ‪.True‬‬


                                                      ‫أداة اﻻﺧﺘﻴﺎر ‪CheckBox‬‬
‫ﺗﻌﻄﻲ هﺬﻩ اﻻداة ﻓﺮﺻﺔ ﻟﻠﻤﺴـﺘﺨﺪم ﻟﺘﺤﺪﻳـﺪ اﺧﺘﻴـﺎر ﻣﻌـﻴﻦ اﻣـﺎ ﺑﺘﻔﻌﻴﻠـﻪ او ﻻ، ﻗﻴﻤـﺔ‬
‫اﻟﺘﻔﻌﻴﻞ ﺗﺤﺘﺠﺰ ﻓﻲ اﻟﺨﺎﺻﻴﺔ ‪ Value‬واﻟﺘﻲ ﺗﻜـﻮن اﻣـﺎ ‪ 1-Checked ،0-UnChecked‬او‬
                                                ‫16‬


‫‪ ،2-Grayed‬ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻘﻴﻤﺔ اﻻﺧﻴﺮة، ﻓﻴﻌﺘﻘﺪ ﻣﻌﻈـﻢ اﻟﻤﺒـﺮﻣﺠﻴﻦ اﻧﻬـﺎ ﺗﺸـﺒﻪ اﻟﻘﻴﻤـﺔ‬
‫‪ False‬ﻟﻠﺨﺎﺻﻴﺔ ‪ ،Enabled‬وهﺬا اﻻﻋﺘﻘﺎد ﺧـﺎﻃﺊ 001% ﻻن اﻟﻘﻴﻤـﺔ ‪ False‬ﻟﻠﺨﺎﺻـﻴﺔ‬
‫‪ Enabled‬ﺗﻤﻨﻊ اﻟﻤﺴﺘﺨﺪم ﻣﻦ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻻداة، ﺑﻴﻨﻤﺎ اﻟﻘﻴﻤﺔ ‪ 2-Grayed‬ﺗﻤﻜﻨﻪ ﻣﻦ‬
‫ذﻟﻚ، ﺗﺴـﺘﻄﻴﻊ اﺳـﺘﺨﺪام هـﺬﻩ اﻟﺨﺎﺻـﻴﺔ ﻓـﻲ ﺣـﺎﻻت ﻣـﺎ ﺑـﻴﻦ ﺗﺤﺪﻳـﺪ اﻻﺧﺘﻴـﺎر او ﻻ،‬
‫آﺘﺤﺪﻳــﺪ ﻣﺠﻤﻮﻋــﺔ اﺧﺘﻴــﺎرات ﻓﺮﻋﻴــﺔ آﻠﻬــﺎ او ﺑﻌﻀــﻬﺎ او ﻋــﺪم ﺗﺤﺪﻳــﺪهﺎ، ﻓــﻲ اﻣﻠــﻒ‬
                                     ‫‪ Codes.ZIP‬ﺗﺠﺪ ﻣﺜﺎﻻ ﺗﻄﺒﻴﻘﻴﺎ ﻋﻠﻰ هﺬﻩ اﻟﻘﻴﻤﺔ.‬
‫ﻣﻦ اﻟﻀﺮوري ان ﺗﻀﻊ ﻓﻲ ذهﻨﻚ ﺑﺎن اﻟﺤـﺪث ‪ Click‬ﻳـﺘﻢ ﺗﻔﺠﻴـﺮﻩ ﻋﻨـﺪ ﻗﻴﺎﻣـﻚ ﺑﺘﻌـﺪﻳﻞ‬
‫ﻗﻴﻤﺔ اﻟﺨﺎﺻـﻴﺔ ‪ Value‬ﺣﺘـﻰ ﻟـﻮ ﻟـﻢ ﻳﻘـﻢ اﻟﻤﺴـﺘﺨﺪم ﺑـﺎﻟﻨﻘﺮ ﻋﻠـﻰ اﻻداة. وﺑﺎﻟﻨﺴـﺒﺔ‬
‫ﻟﺨﺼــﺎﺋﺺ اﻟﺼــﻮر ‪ DisablePicture ،Picture‬و ‪ DownPicture‬ﻓﻠــﻦ ﺗــﺘﻤﻜﻦ ﻣــﻦ رؤﻳــﺔ‬
                           ‫ﻧﺘﺎﺋﺠﻬﺎ ﺣﺘﻰ ﺗﻐﻴﺮ ﻗﻴﻤﺔ اﻟﺨﺎﺻﻴﺔ ‪ Style‬اﻟﻰ ‪.1-Graphical‬‬


                ‫ﺎ‬
 ‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﺨﺎﺻﻴﺔ ‪ Caption‬ﻓﻬﻲ ﺗﺘﺄﺛﺮ ﺑﺎﻟﺮﻣﺰ "&" ﺗﻤﺎﻣً آﻤﺎ ﺗﺘﺄﺛﺮ أداة‬        ‫ﻣﻼﺣﻈﺔ:‬
                              ‫زر اﻻواﻣﺮ ‪ CommandButton‬ﺑﻬﺬا اﻟﺮﻣﺰ.‬

                                                ‫زر اﻻﺧﺘﻴﺎر ‪OptionButton‬‬
‫زر اﻻﺧﺘﻴﺎر ‪ OptionButton‬ﻳﺴﻤﻰ اﺣﻴﺎﻧﺎ ﺑﺰر اﻟﺮادﻳﻮ ‪ Radio Button‬وهﻮ ﺷـﺒﻴﻪ ﺑـﺄداة‬
‫اﻻﺧﺘﻴﺎر ‪ ،CheckBox‬اﻻ ان ﻗﻴﻤﺔ اﻟﺨﺎﺻﻴﺔ ‪ Value‬ﺗﻜﻮن اﻣـﺎ ‪ True‬او ‪ .False‬آـﺬﻟﻚ ﻟـﻦ‬
‫ﺗﺴﺘﻄﻴﻊ ﺟﻌﻞ ﻗﻴﻤﺔ اﻟﺨﺎﺻﻴﺔ ‪ Value‬اﻟﻰ ‪ True‬ﻻآﺜﺮ ﻣﻦ زر اﺧﺘﻴـﺎر واﺣـﺪ ﻓـﻲ ﻧﻔـﺲ‬
‫اﻟﻤﺠﻤﻮﻋﺔ -أي ﻧﻔﺲ اﻻداة او ﻧﺎﻓﺬة اﻟﻨﻤﻮذج اﻟﺤﺎﺿﻨﺔ، ﻟﺬﻟﻚ ﻳﻔﻀﻞ وﺿـﻊ هـﺬﻩ اﻻزرار‬
‫ﻓﻲ داﺧﻞ اداة اﻻﻃﺎر ‪ Frame‬وﺗﺮﺗﻴﺒﻬﺎ ﻋﻠـﻰ ﻣﺠﻤﻮﻋـﺎت ﺗﻨﺎﺳـﺐ ﺗﺼـﻨﻴﻒ اﻻﺧﺘﻴـﺎرات.‬
‫وﺑﺎﻟﻨﺴﺒﺔ ﻟﺨﺼﺎﺋﺺ اﻟﺼﻮر ‪ DisablePicture ،Picture‬و ‪ DownPicture‬ﻓﻠﻦ ﺗﺘﻤﻜﻦ ﻣﻦ‬
                     ‫رؤﻳﺔ ﻧﺘﺎﺋﺠﻬﺎ ﺣﺘﻰ ﺗﻐﻴﺮ ﻗﻴﻤﺔ اﻟﺨﺎﺻﻴﺔ ‪ Style‬اﻟﻰ ‪.1-Graphical‬‬

                ‫ﺎ‬
 ‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﺨﺎﺻﻴﺔ ‪ Caption‬ﻓﻬﻲ ﺗﺘﺄﺛﺮ ﺑﺎﻟﺮﻣﺰ "&" ﺗﻤﺎﻣً آﻤﺎ ﺗﺘﺄﺛﺮ أداة‬        ‫ﻣﻼﺣﻈﺔ:‬
                              ‫زر اﻻواﻣﺮ ‪ CommandButton‬ﺑﻬﺬا اﻟﺮﻣﺰ.‬


                                                       ‫أداة اﻟﻘﺎﺋﻤﺔ ‪ListBox‬‬
‫ﺗﻌﺮض ﻟﻚ هﺬﻩ اﻻداة ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻨﺼﻮص ﻓﻲ داﺧﻞ ﺻﻨﺪوق ﻳﺤﺘﻮي ﻋﻠﻰ اﺷـﺮﻃﺔ‬
‫ﺗﻤﺮﻳﺮ ‪ .ScorllBars‬اﻟﺨﺎﺻﻴﺔ ‪ Sorted‬ﺗﻘﻮم ﺑﻔﺮز ﻣﺤﺘﻮﻳﺎت اﻻداة ﻓﺮز ﺗﺼﺎﻋﺪي ﺑﺎﻻﺳـﺘﻨﺎد‬
   ‫ـ‬      ‫ـ‬          ‫ـ‬     ‫ـ‬
‫ﻋﻠـﻰ ﺣﺮوﻓﻬ ـﺎ اﻻﺑﺠﺪﻳ ـﺔ، ﻣ ـﻊ اﻟﻌﻠ ـﻢ ان اﻟﺤـﺮوف اﻟﻌﺮﺑﻴ ـﺔ ﺳ ـﺘﻜﻮن –ﻟﻼﺳ ـﻒ- اﺳ ـﻔﻞ‬
                                     ‫ـ‬        ‫ـ‬       ‫ـ‬     ‫ـ‬         ‫ـ‬        ‫ـ‬
‫اﻟﺤﺮوف اﻻﻧﺠﻠﻴﺰﻳﺔ. ﺗﺴﺘﻄﻴﻊ ﻋﺮض آـﻞ ﻣﺤﺘﻮﻳـﺎت اﻻداة ﻋﻠـﻰ ﺷـﻜﻞ اﻋﻤـﺪة وﺗﻠﻐـﻰ‬
‫ﺷﺮﻳﻂ اﻟﺘﻤﺮﻳﺮ اﻟﻌﻤـﻮدي ﻟﺘﻈﻬـﺮ ﺷـﺮﻳﻂ اﻟﺘﻤﺮﻳـﺮ اﻻﻓﻘـﻲ، ﺳـﻴﻜﻮن ﻋـﺪد اﻻﻋﻤـﺪة هـﻮ‬
                                                  ‫26‬


‫ﻧﻔﺲ اﻟﻌﺪد اﻟﻤﻮﺟﻮد ﻓﻲ اﻟﺨﺎﺻﻴﺔ ‪ Columns‬رﻏﻢ اﻧﻲ ﻻ اﺣﺒـﺬ هـﺬﻩ اﻟﻄﺮﻳﻘـﺔ ﻟﻌـﺮض‬
                                                                       ‫ﻣﺤﺘﻮﻳﺎت اﻻداة.‬
‫ﺗﻐﻴﻴــﺮ ارﺗﻔــﺎع اﻻداة ‪ Height‬ﻟــﻦ ﻳﻜــﻮن دﻗﻴﻘــﺎ آﻤــﺎ هــﻮ اﻟﺤــﺎل ﻣــﻊ اﻻدوات اﻻﺧــﺮى،‬
‫واﻟﺴﺒﺐ ان ‪ Visual Basic‬ﻳﺤﺎول ﺗﻌﺪﻳﻞ ارﺗﻔﺎع اﻻداة ﺣﺘﻰ ﺗﻌﺮض اﻟﺴـﻄﺮ آـﺎﻣﻼ ﻓـﻲ‬
‫اﻟﻘﺎﺋﻤﺔ، ﻓﻠﻦ ﺗﺴﺘﻄﻴﻊ ﻋﺮض ﻧﺼﻒ اﻟﺴﻄﺮ اﻻ اذا ﻗﻤﺖ ﺑﺎﻟﻐـﺎء اﻟﻤﺤـﺎذاة اﻟﺘـﻲ ﻳﻔﻌﻠﻬـﺎ‬
        ‫‪ Visual Basic‬ﻋﻦ ﻃﺮﻳﻖ ﺟﻌﻞ ﻗﻴﻤﺔ اﻟﺨﺎﺻﻴﺔ ‪ IntegralHeight‬ﺗﺴﺎوي ‪.False‬‬
‫ﺗﺴﺘﻄﻴﻊ ﺗﻌﺒﺌﺔ ﻣﺤﺘﻮﻳﺎت اﻻداة ﻓﻲ وﻗﺖ اﻟﺘﺼـﻤﻴﻢ ﻋـﻦ ﻃﺮﻳـﻖ اﻟﺨﺎﺻـﻴﺔ ‪ List‬او وﻗـﺖ‬
                                                 ‫اﻟﺘﻨﻔﻴﺬ ﺑﺎﺳﺘﺨﺪام اﻟﻄﺮﻳﻖ ‪:AddItem‬‬

‫”اﻻول“ ‪List1.AddItem‬‬
‫”اﻟﺜﺎﻧﻲ“ ‪List1.AddItem‬‬
‫”اﻟﺜﺎﻟﺚ“ ‪List1.AddItem‬‬

‫اذا آﻨﺖ ﺳﺘﻀﻴﻒ ﻣﺌﺎت او اﻻف اﻟﻌﻨﺎﺻﺮ وﻗﺖ اﻟﺘﻨﻔﻴﺬ، ﻓﻴﻨﺼﺢ ﺑﺎﺧﻔﺎء اﻻداة ﻣﺆﻗﺘﺎ وﺑﻌﺪ‬
    ‫ﺎ‬
‫اﺿﺎﻓﺔ اﻟﻌﻨﺎﺻﺮ ﺗﻌﻴﺪ اﻇﻬﺎرهﺎﻣﻦ ﺟﺪﻳﺪ، وذﻟﻚ ﻷن اﻻداة ﺗﻌﻴﺪ رﺳﻢ ﻧﻔﺴﻬﺎ ﺗﻠﻘﺎﺋﻴـً ﻣـﻊ‬
            ‫اﺿﺎﻓﺔ أي ﻋﻨﺼﺮ إﻟﻴﻬﺎ، ﻣﻤﺎ ﻳﺘﺴﺒﺐ ﻓﻲ ﺑﻂء اﻟﺘﻨﻔﻴﺬ وآﺬﻟﻚ ارﺗﻌﺎش اﻻداة:‬

‫‪List1.Visible = False‬‬
‫00001 ‪For X = 0 To‬‬
        ‫‪List1.AddItem X‬‬
‫‪Next‬‬
‫‪List1.Visible = True‬‬

‫اﻟﻌﻨﺎﺻﺮ اﻟﺠﺪﻳﺪة ﺗﻀﺎف اﻟﻰ ﻧﻬﺎﻳﺔ ﺳﻠﺴﻠﺔ اﻟﻌﻨﺎﺻﺮ -اذا آﺎﻧﺖ ﻗﻴﻤـﺔ اﻟﺨﺎﺻـﻴﺔ ‪Sorted‬‬
                                       ‫ﺗﺴﺎوي ‪ -False‬ﻣﺎﻟﻢ ﺗﺤﺪد ﻣﻮﻗﻌﻬﺎ ﺑﻨﻔﺴﻚ:‬

‫”اﻟﺜﺎﻟﺚ“ ‪List1.AddItem‬‬
‫0 ,”اﻻول“ ‪List1.AddItem‬‬
‫1 ,”اﻟﺜﺎﻧﻲ“ ‪List1.AddItem‬‬

‫ﺗﺬآﺮ ان ﺗﺤﺪﻳﺪ ﻣﻮﻗﻊ اﻟﻌﻨﺼﺮ ﻳﺆﺛﺮ ﻓﻲ ﺗﺮﺗﻴﺐ اﻟﻌﻨﺎﺻﺮ اﻻﺧـﺮى. ﺑﺎﻣﻜﺎﻧـﻚ ﺣـﺬف اﻟﻌﻨﺼـﺮ‬
          ‫ﺑﺎﺳﺘﺨﺪام اﻟﻄﺮﻳﻘﺔ ‪ RemoveItem‬او اﻟﻄﺮﻳﻘﺔ ‪ Clear‬ﻟﺤﺬف ﺟﻤﻴﻊ اﻟﻌﻨﺎﺻﺮ:‬

‫0 ‪List1.RemoveItem‬‬
‫‪List1.Clear‬‬
                                                ‫36‬



‫اﻟﺨﺎﺻﻴﺔ ‪ ListIndex‬ﺗﻌﻮد ﺑﻘﻴﻤﺔ اﻟﻌﻨﺼﺮ اﻟﻤﺤﺪد ﻓـﻲ اﻻداة، وﺗﻌـﻮد ﺑﺎﻟﻘﻴﻤـﺔ -1 ان ﻟـﻢ‬
‫ﻳﻜﻦ هﻨﺎك أي ﻋﻨﺼﺮ ﻣﺤﺪد، ﺑﺎﻣﻜﺎﻧﻚ ﺗﻌﺪﻳﻞ ﻗﻴﻤـﺔ اﻟﺨﺎﺻـﻴﺔ اﻳﻀـﺎ، اﻣـﺎ اﻟﺨﺎﺻـﻴﺔ ‪Text‬‬
                                                  ‫ﻓﻬﻲ ﺗﻌﻮد ﺑﻨﺺ اﻟﻌﻨﺼﺮ اﻟﻤﺤﺪد:‬

‫0 = ‪List1.ListIndex‬‬
‫‪Print List1.Text‬‬

‫ﺑﺎﻟﻨﺴــﺒﺔ ﻟﻠﺨﺎﺻــﻴﺔ ‪ ListCount‬ﻓﻬــﻲ ﺗﻌــﻮد ﺑﻌــﺪد ﺟﻤﻴــﻊ اﻟﻌﻨﺎﺻــﺮ اﻟﻤﻮﺟــﻮدة، واﻟﺘــﻲ‬
               ‫ﺗﺴﺘﺨﺪم ﺑﻜﺜﺮة ﻣﻊ اﻟﺨﺎﺻﻴﺔ ‪ List‬اﻟﺘﻲ ﺗﻤﻜﻨﻚ ﻣﻦ اﻟﻮﺻﻮل اﻟﻰ اﻟﻌﻨﺼﺮ:‬

‫‪For X = 0 To List1.ListCount‬‬
       ‫)0( ‪Print List1.List‬‬
‫‪Next‬‬

               ‫ـ‬                       ‫ـ‬                                   ‫ـ‬
‫ﺑﺎﻟﻨﺴ ـﺒﺔ ﻟﻠﺨﺎﺻــﻴﺔ ‪ MultiSelect‬ﻓﻬــﻲ ﺗﻤﻜ ـﻦ اﻟﻤﺴــﺘﺨﺪم ﻣــﻦ ﺗﺤﺪﻳ ـﺪ ﻋــﺪة ﻋﻨﺎﺻــﺮ‬
‫ﻣﺘﺘﺎﻟﻴﺔ ﻓﻲ اﻻداة اذا آﺎﻧﺖ ﻗﻴﻤﺘﻬﺎ ‪ 1-Simple‬او ﻋﺪة ﻋﻨﺎﺻﺮ ﻏﻴﺮ ﻣﺘﺘﺎﻟﻴﺔ –ﺑﺎﺳـﺘﺨﺪام‬
‫اﻟﻤﻔﺘﺎح ]‪ -[Ctrl‬اذا آﺎﻧﺖ ﻗﻴﻤﺘﻬﺎ ‪ ،2-Extended‬وﺗﺴﺘﻄﻴﻊ ﻣﻌﺮﻓﺔ اﻟﻌﻨﺼﺮ اﻟﻤﺤـﺪد ﻋـﻦ‬
‫ﻃﺮﻳﻖ اﻟﺨﺎﺻﻴﺔ ‪ ،Selected‬هﺬا اﻟﻜﻮد ﻳﻨﻘﻞ ﺟﻤﻴﻊ اﻟﻌﻨﺎﺻﺮ اﻟﻤﺤـﺪدة ﻣـﻦ اداة اﻟﻘﺎﺋﻤـﺔ‬
                                                                      ‫اﻟﻰ اﺧﺮى:‬

‫)(‪Private Sub cmdMoveLeft_Click‬‬
   ‫‪Dim iCounter As Integer‬‬

   ‫0 = ‪iCounter‬‬

  ‫1 - ‪Do While iCounter <= lstRight.ListCount‬‬
     ‫‪If lstRight.Selected(iCounter) = True Then‬‬
         ‫)‪lstLeft.AddItem lstRight.List(iCounter‬‬
         ‫‪lstRight.RemoveItem iCounter‬‬
         ‫1 - ‪iCounter = iCounter‬‬
     ‫‪End If‬‬
     ‫1 + ‪iCounter = iCounter‬‬
  ‫‪Loop‬‬
‫‪End Sub‬‬
                                               ‫46‬


               ‫ـ‬             ‫ـ‬         ‫ـ‬                 ‫ـ‬          ‫ـ‬          ‫ـ‬
‫ﺗﺴـ ـﺘﺨﺪم ﻧﻔـ ـﺲ اﻟﺨﺎﺻـ ـﻴﺔ ‪ Selected‬اﻳﻀـ ـﺎ ﻟﻤﻌﺮﻓـ ـﺔ ادوات اﻻﺧﺘﻴـ ـﺎر ‪CheckBoxes‬‬
‫اﻟﻤﺤﺪدة ﺑﺠﺎﻧﺐ اﺳﻤﺎء اﻟﻌﻨﺎﺻﺮ واﻟﺘﻲ ﺗﻈﻬﺮ اذا آﺎﻧـﺖ ﻗﻴﻤـﺔ اﻟﺨﺎﺻـﻴﺔ ‪ Style‬ﺗﺴـﺎوي‬
                                                                     ‫‪.1-CheckBox‬‬
‫اﺧﻴﺮا، اﻟﺤﺪث ‪ Scroll‬ﻳﺘﻢ ﺗﻔﺠﻴﺮﻩ ﺑﻤﺠﺮد ﻗﻴﺎم اﻟﻤﺴﺘﺨﺪم ﺑﺎﺳﺘﺨﺪام اﺷـﺮﻃﺔ اﻟﺘﻤﺮﻳـﺮ‬
                                                          ‫‪ ScrollBars‬اﻟﺘﺎﺑﻌﺔ ﻟﻼداة.‬

                                                 ‫أداة اﻟﻘﺎﺋﻤﺔ ‪ComboBox‬‬
‫ﻣﻌﻈــﻢ اﻟﺨﺼــﺎﺋﺺ واﻟﻄــﺮق اﻟﺘﺎﺑﻌــﺔ ﻟــﻼداة ‪ ListBox‬اﻟﺴــﺎﺑﻘﺔ ﻣﻮﺟــﻮدة ﻓــﻲ اﻻداة‬
‫‪ ،ComboBox‬وذﻟﻚ ﻻن اﻻداة ‪ ComboBox‬ﻋﺒﺎرة ﻋـﻦ أداة ‪ ListBox‬ﻗﻴﺎﺳـﻴﺔ وﺗﺤﺘـﻮي‬
‫ﻋﻠﻰ ﺧﺎﻧﺔ ﻧﺺ ‪ TextBox‬اﺿﺎﻓﻴﺔ ﻓﻲ اﻋﻼهﺎ، ﺗﺴﺘﻄﻴﻊ ﻋﺮض ﺧﺎﻧﺔ اﻟﻨﺺ ﺑﻌـﺪة ﻃـﺮق‬
‫ﺑﺎﺳـﺘﺨﺪام اﻟﺨﺎﺻـﻴﺔ ‪ .Style‬اذا آﺎﻧـﺖ ﻗﻴﻤـﺔ اﻟﺨﺎﺻـﻴﺔ ‪ Style‬ﺗﺴـﺎوي ‪0-Dropdown‬‬
‫‪ Combo‬ﻓﺎن اداة اﻟﻨﺺ ﺳﺘﻈﻬﺮ ﻣﻊ ﺳﻬﻢ ﻳﺆدي اﻟﻨﻘﺮ ﻋﻠﻴﻪ اﻟـﻰ ﻇﻬـﻮر اﻟﺠـﺰء اﻟﺜـﺎﻧﻲ‬
‫ﻣﻦ اﻻداة –اﻟﺸـﺒﻴﻪ ﺑـﺎﻻداة ‪ ،ListBox‬واذا آﺎﻧـﺖ ﻗﻴﻤـﺔ اﻟﺨﺎﺻـﻴﺔ ﺗﺴـﺎوي ‪1-Simple‬‬
‫‪ Combo‬ﻓﻜﻼ اﻟﺠﺰﺋﻴﻦ ﺳﻴﻈﻬﺮان ﻟﻠﻤﺴﺘﺨﺪم، اﻣﺎ اذا آﺎﻧﺖ ﻗﻴﻤﺔ اﻟﺨﺎﺻﻴﺔ ﺗﺴﺎوي -2‬
‫‪ Dropdown List‬ﻓﻬﻲ ﻣﺜﻞ اﻟﻘﻴﻤـﺔ اﻻوﻟـﻰ ﺑﺎﺳـﺜﻨﺎء ان اﻟﻤﺴـﺘﺨﺪم ﻟـﻦ ﻳـﺘﻤﻜﻦ ﻣـﻦ‬
                                                            ‫اﻟﻜﺘﺎﺑﺔ ﻓﻲ ﺧﺎﻧﺔ اﻟﻨﺺ.‬
‫اﻣﺎ اﻟﺤـﺪﻳﺚ ﻋـﻦ اﻻﺣـﺪاث ﻓﻬـﻲ ﺗﺤﺘـﻮي ﻣﻌﻈـﻢ اﻻﺣـﺪاث اﻟﻘﻴﺎﺳـﻴﺔ واﻟﺤـﺪث ‪Scorll‬‬
‫اﻟﻤﻮﺟﻮد ﻓﻲ اﻻداة ‪ ،ListBox‬اﻻ ان ﻓﺮﻳﻖ اﻟﺘﻄﻮﻳﺮ ﻟـ ‪ Visual Basic‬او –ان ﺻﺢ اﻟﺘﻌﺒﻴـﺮ-‬
‫اﻟﻤﻄﻮر اﻟﺬي ﻗﺎم ﺑﺒﺮﻣﺠﺔ اﻻداة ‪ ComboBox‬ﻗﺪ ﻧﺴﻲ اﺿﺎﻓﺔ اﻻﺣﺪاث ‪،MouseDown‬‬
‫‪ MouseMove‬و ‪ !MouseUp‬اذا ﺻﺎدﻓﺘﻪ ﻳﻮﻣﺎ ﻣﻦ اﻻﻳﺎم ﻓﺎرﺟﻮ ان ﺗﻨﺼﺤﻪ ﺑﺘﻨﺎول اﻓﻄﺎرﻩ‬
                                            ‫ﻗﺒﻞ اﻟﺬهﺎب اﻟﻰ ﻣﻜﺘﺒﻪ ﻓﻲ ‪.Microsoft‬‬

                                                 ‫أداة اﻟﺼﻮرة ‪PictureBox‬‬
‫ﻳﻤﻜﻨﻚ اﻋﺘﺒﺎر اداة اﻟﺼـﻮرة ‪ PictureBox‬ﻋﻠـﻰ اﻧﻬـﺎ ﻧﺎﻓـﺬة ﻧﻤـﻮذج ‪ Form‬ﺑـﺪون ﺷـﺮﻳﻂ‬
         ‫ـ‬     ‫ـ‬         ‫ـ‬        ‫ـ‬
‫ﻋﻨــﻮان، ﻓﻤﻌﻈــﻢ ﺧﺼــﺎﺋﺺ، ﻃــﺮق واﺣــﺪاث ﻧﺎﻓــﺬة اﻟﻨﻤــﻮذج ﻣﻮﺟــﻮدة ﻓــﻲ اﻻداة‬
                                          ‫ـ‬        ‫ـ‬         ‫ـ‬      ‫ـ‬           ‫ـ‬
‫‪ PictureBox‬ﻟﺬﻟﻚ ﻻ ﻳﻮﺟﺪ داﻋﻲ ﻻﻋﺎدة ذآﺮهﺎ ﻓـﻲ هـﺬﻩ اﻟﻔﻘـﺮة ﺑﺎﺳـﺘﺜﻨﺎء اﻟﺨﺎﺻـﻴﺔ‬
‫‪ AutoSize‬اﻟﺘﻲ ﺗﻌﺪل ﺣﺠﻢ اﻻداة ﺑﺤﻴﺚ ﺗﻌﺮض ﺟﻤﻴﻊ ﻣﺤﺘﻮﻳﺎت اﻟﺼﻮرة اﻟﻤﻮﺟﻮدة ﻓﻲ‬
‫اﻻداة -أي اﻟﺼــﻮرة اﻟﻤﻮﺟــﻮدة ﻓــﻲ اﻟﺨﺎﺻــﻴﺔ ‪ .Picture‬آﻤــﺎ ان اﻻداة ‪ PictureBox‬اداة‬
                                 ‫ﺣﺎﺿﻨﺔ ﻳﻤﻜﻨﻬﺎ ان ﺗﺤﺘﻀﻦ ادوات اﺧﺮى ﻓﻲ داﺧﻠﻬﺎ.‬

                                                        ‫أداة اﻟﺼﻮرة ‪Image‬‬
                      ‫ـ‬            ‫ـ‬     ‫ـ‬       ‫ـ‬     ‫ـ‬            ‫ـ‬
‫اداة اﻟﺼ ـﻮرة ‪ Image‬ه ـﻲ ﻧﺴ ـﺨﺔ ﻣﺒﺴ ـﻄﺔ ﻣ ـﻦ اﻻداة اﻟﺴ ـﺎﺑﻘﺔ ‪ ،PictureBox‬ﻓﻬــﻲ‬
‫ﺗﻌﺮض اﻟﺼﻮر ﻋﻦ ﻃﺮﻳﻖ ﺧﺎﺻﻴﺘﻬﺎ ‪ Picture‬اﻻ اﻧﻬﺎ ﻻ ﺗﺪﻋﻢ اﻟﺨﺼﺎﺋﺺ اﻟﻤﺘﻘﺪﻣﺔ ﻟﻠﺼـﻮر‬
                                               ‫56‬


‫آـ ‪ .... DrawMode ،AutoRedraw ،HasDC‬اﻟﺦ آﻤﺎ اﻧﻬﺎ ﻻ ﺗﺪﻋﻢ ﻃﺮق اﻟﺮﺳﻢ ‪،Line‬‬
‫‪ .... Cirlce‬اﻟﺦ، واﻻﺣﺪاث ‪ .... Resize ،Paint‬اﻟﺦ، اذا آﻨﺖ ﻻ ﺗﻨـﻮي اﺳـﺘﺨﺪاﻣﻬﺎ ﻓﻘـﺪ‬
‫ﺗﺨﺴﺮ اﻟﻜﺜﻴﺮ! ﻻن اﻻداة ‪ Image‬هﻲ اداة ﻣـﻦ اﻟﻨـﻮع ﻣﻌﺪوﻣـﺔ اﻟﻨﻮاﻓـﺬ ‪Windowless‬‬
‫‪ Control‬أي اﻧﻬــﺎ اﺳــﺮع ﺑﻜﺜﻴــﺮ ﻣــﻦ اﻻداة ‪ ،PictureBox‬آﻤــﺎ ان اﺳــﺘﻬﻼآﻬﺎ ﻟﻤﺼــﺎدر‬
‫اﻟﻨﻈﺎم ‪ System Resources‬اﻗﻞ ﺑﻜﺜﻴﺮ ﻣﻦ اﻻداة ‪ .PictureBox‬ﻓـﺎذا آـﺎن اﺳـﺘﺨﺪاﻣﻚ‬
‫ﻻدوات اﻟﺼﻮرة ﻗﺎﺻﺮا ﻋﻠﻰ ﻋﺮض اﻟﺼﻮر ﻓﻘﻂ، اﺳﺘﺨﺪم اﻻداة ‪ Image‬ﻋﻮﺿﺎ ﻋﻦ اﻻداة‬
                                                                         ‫‪.PictureBox‬‬

                                             ‫اﺷﺮﻃﺔ اﻟﺘﻤﺮﻳﺮ ‪ScrollBars‬‬
‫ﺗﻤﻜﻨﻚ اﻻداﺗﻴﻦ ‪ HScorllBar‬و ‪ VScorllBar‬ﻣﻦ ﻣﺤﺎآﺎة اﺷﺮﻃﺔ اﻟﺘﻤﺮﻳﺮ اﻟﻤﻨﺘﺸﺮة ﻓـﻲ‬
‫ﻧﻮاﻓﺬ وﺗﻄﺒﻴﻘﺎت ‪ .Windows‬اﺑﺪأ ﺑﺎﻟﺨﺎﺻـﻴﺘﻴﻦ ‪ Min‬و ‪ Max‬ﻟﺘﺤﺪﻳـﺪ ﻣﺠـﺎل اﻟﻘـﻴﻢ اﻟﺘـﻲ‬
‫ﻳﻤﻜﻨﻚ ﻗﺮاﺋﺘﻬﺎ او آﺘﺎﺑﺘﻬﺎ ﻋـﻦ ﻃﺮﻳـﻖ اﻟﺨﺎﺻـﻴﺔ ‪ ،Value‬واﻟﺘـﻲ ﺗﻤﺜـﻞ اﻟﻤﻮﻗـﻊ اﻟﺤـﺎﻟﻲ‬
‫ﻟﻠﻤﺴﺘﻄﻴﻞ اﻟﻤﺘﺤﺮك ﻓﻲ ﺷﺮﻳﻂ اﻟﺘﻤﺮﻳﺮ. ﺑﻌﺪ ذﻟﻚ، ﺣـﺪد ﻗﻴﻤـﺔ اﻟﺘﻐﻴﻴـﺮ اﻟﺒﺴـﻴﻂ ﻋـﻦ‬
‫ﻃﺮﻳــﻖ اﻟﺨﺎﺻــﻴﺔ ‪ SmallChange‬وهــﻲ ﻣﻘــﺪار اﻟﺘﻐﻴﻴــﺮ ﻓــﻲ اﻟﻘﻴﻤــﺔ ﻋﻨــﺪﻣﺎ ﻳﻘــﻮم‬
‫اﻟﻤﺴﺘﺨﺪم ﺑﺎﻟﻨﻘﺮ ﻋﻠﻰ اﺣﺪ ازرار اﺷﺮﻃﺔ اﻟﺘﻤﺮﻳﺮ، اﻣﺎ اﻟﺨﺎﺻـﻴﺔ ‪ LargeChange‬ﻓﻬـﻲ‬
  ‫ﻣﻘﺪار اﻟﺘﻐﻴﻴﺮ ﻓﻲ اﻟﻘﻴﻤﺔ ﻋﻨﺪﻣﺎ ﻳﻘﻮم اﻟﻤﺴﺘﺨﺪم ﺑﺎﻟﻨﻘﺮ ﻋﻠﻰ ﺷﺮﻳﻂ اﻟﺘﻤﺮﻳﺮ ﻧﻔﺴﻪ.‬
‫ﻓﻲ ﻟﻐﺔ ‪ Delphi‬ﺗﻮﺟﺪ ﺧﺎﺻﻴﺔ ﺗﻌﺮض اﺷﺮﻃﺔ اﻻدوات ﻋﻠﻰ ﻧﻮاﻓﺬ اﻟﻨﻤﺎذج ﻣﺒﺎﺷﺮة، اﻣﺎ‬
‫ﻣﻊ ‪ Visual Basic‬ﻓﻠﻼﺳﻒ ﻻ ﺗﻮﺟﺪ، اذا آﻨﺖ ﺗﺮﻳﺪ وﺿـﻊ اﺷـﺮﻃﺔ ادوات ﻋﻠﻴﻬـﺎ، ﻓﺎﻧـﺖ‬
‫اﻟﻤﺴﺆول اﻻول واﻻﺧﻴـﺮ ﻋـﻦ ﻇﻬﻮرهـﺎ، اﺧﻔﺎﺋﻬـﺎ وﺗﺤﺮﻳـﻚ اﻻدوات، وﺑﺎﻟﻨﺴـﺒﺔ ﻟﺘﺤﺮﻳـﻚ‬
‫اﻻدوات ﻓﻴﻔﻀﻞ اﺣﺘﻀﺎن اﻻدوات ﻓﻲ اداة ‪ PictureBox‬ﺣﺘﻰ ﺗﺴـﻬﻞ ﻋﻤﻠﻴـﺔ اﻟﺘﺤﺮﻳـﻚ‬
                                                                           ‫ﻋﻠﻴﻚ:‬

‫)(‪Private Sub Form_Resize‬‬
   ‫‪If Me.ScaleHeight < picMain.Height Then‬‬
      ‫‪VScroll1.Move 0, 0, VScroll1.Width, Me.ScaleHeight - HScroll1.Height‬‬
      ‫‪picMain.Left = VScroll1.Width‬‬
      ‫0 = ‪VScroll1.Min‬‬
      ‫)‪VScroll1.Max = -(picMain.Height - Me.ScaleHeight‬‬
      ‫05 = ‪VScroll1.SmallChange‬‬
      ‫005 = ‪VScroll1.LargeChange‬‬
   ‫‪Else‬‬
      ‫0 = ‪picMain.Left‬‬
      ‫‪VScroll1.Move Me.ScaleWidth + VScroll1.Width‬‬
   ‫‪End If‬‬
                                                 ‫66‬


  ‫‪If Me.ScaleWidth < picMain.Width Then‬‬
     ‫_ ,‪HScroll1.Move VScroll1.Width, Me.ScaleHeight - HScroll1.Height‬‬
                     ‫‪Me.ScaleWidth - VScroll1.Width‬‬
     ‫0 = ‪HScroll1.Min‬‬
     ‫)‪HScroll1.Max = -(picMain.Width - Me.ScaleWidth‬‬
     ‫05 = ‪HScroll1.SmallChange‬‬
     ‫005 = ‪HScroll1.LargeChange‬‬
  ‫‪Else‬‬
     ‫‪HScroll1.Move 0, Me.ScaleHeight + HScroll1.Height‬‬
  ‫‪End If‬‬
‫‪End Sub‬‬


                                                                  ‫ادوات اﻟﻤﻠﻔﺎت‬
‫ﻣــﻦ اﻟﻮاﺿــﺢ ان ادوات اﻟﻤﻠﻔــﺎت ‪ DirListBox ،DriverListBox‬و ‪ FileListBox‬ﻏﺮﺿــﻬﺎ‬
‫اﻻﺳﺎﺳﻲ هﻮ ﻋﺮض ﻣﻠﻔﺎت اﻟﺠﻬﺎز، ﻳﻌﻴﺒﻬﺎ اﻧﻬﺎ ادوات ﻗﺪﻳﻤﺔ ﺟﺪا، وﺷﻜﻠﻬﺎ اﻟﺨﺎرﺣﻲ‬
‫ﻻ ﻳﻼﺋــﻢ ادوات ﻋــﺮض اﻟﻤﻠﻔــﺎت اﻟﺸــﺎﺋﻌﺔ ﻟﺒﻴﺌــﺔ ‪ ،Windows‬ورﻏــﻢ اﻧﻨــﻲ ﻻ اﺣﺒــﺬ‬
‫اﺳﺘﺨﺪاﻣﻬﺎ، اﻻ اﻧﻨﻲ ﻣﻠﺰم ﺑﺸﺮﺣﻬﺎ ﻓﻬﻲ –ﻋﻠﻰ اﻻﻗﻞ- ﺗﻌﺘﺒﺮ ﻣـﻦ اﻻدوات اﻟﺪاﺧﻠﻴـﺔ،‬
                                                ‫وآﻤﺎ ﻳﻘﻮﻟﻮن: "ﻳﻤﻜﻨﻬﺎ ﺗﻔﻚ ازﻣﺔ!".‬
‫ﻓﻲ اﻏﻠﺐ اﻟﻨﻮاﻓﺬ، ﺗﻌﻤﻞ هﺬﻩ اﻻدوات ﺟﻨﺒـﺎ اﻟـﻰ ﺟﻨـﺐ ﻓﺘﺒـﺪأ ﺑـﺎﻻداة ‪DriverListBox‬‬
        ‫وﺗﺤﺪد ﺣﺮف ﻣﺤﺮك اﻻﻗﺮاص اﻻﺑﺘﺪاﺋﻲ ‪ DiskDrive‬ﻋﻦ ﻃﺮﻳﻖ اﻟﺨﺎﺻﻴﺔ ‪:Drive‬‬

‫)(‪Private Sub Form_Load‬‬
   ‫"\:‪Drive1.Drive = "C‬‬
‫‪End Sub‬‬

‫ﺛــﻢ ﺗﻨﺘﻘــﻞ اﻟــﻰ اﻟﺤــﺪث ‪ Change‬ﺣﺘــﻰ ﺗﻐﻴــﺮ ﻣﺴــﺎر اﻻدﻟــﺔ اﻟﻤﻮﺟــﻮدة ﻓــﻲ اﻻداة‬
‫‪ DirListBox‬ﻓـــﻲ آـــﻞ ﻣـــﺮة ﻳﻘـــﻮم ﺑﻬـــﺎ اﻟﻤﺴـــﺘﺨﺪم ﺑﺘﻐﻴﻴـــﺮ اﻟﻤﺤـــﺮك ﻓـــﻲ اﻻداة‬
                                                                         ‫‪:DriveListBox‬‬

‫)(‪Private Sub Drive1_Change‬‬
   ‫‪Dir1.Path = Drive1.Drive‬‬
‫‪End Sub‬‬
                                                  ‫76‬


‫ﻣﻦ اﻟﻤﻬﻢ ﺟﺪا ﺗﻮﻗﻊ اﻟﺨﻄﺄ ﻓﻲ اﻟﻜﻮد اﻟﺴـﺎﺑﻖ، ﻓﻠـﻮ ﻗـﺎم اﻟﻤﺴـﺘﺨﺪم ﺑﺎﺧﺘﻴـﺎر ﻣﺤـﺮك‬
 ‫ـ‬     ‫ـ‬        ‫ـ‬    ‫ـ‬
‫اﻗ ـﺮاص ﻻ ﻳﻮﺟ ـﺪ ﺑ ـﻪ ﻗ ـﺮص -آ ـﺎﻟﻤﺤﺮك ‪ :A‬ﻣ ـﺜﻼ- ﻓﺮﺳ ـﺎﻟﺔ اﻟﺨﻄ ـﺄ ﺳ ـﺘﻨﻔﺠﺮ ﻓ ـﻲ وﺟ ـﻪ‬
                               ‫ـ‬        ‫ـ‬            ‫ـ‬        ‫ـ ـ ـ‬              ‫ـ‬
                                                        ‫اﻟﻤﺴﺘﺨﺪم وﺗﻨﻬﻲ اﻟﺒﺮﻧﺎﻣﺞ:‬

‫)(‪Private Sub Drive1_Change‬‬
   ‫‪On Error Resume Next‬‬
   ‫‪Dir1.Path = Drive1.Drive‬‬
   ‫‪If Err Then‬‬
      ‫‪Drive1.Drive = Dir1.Path‬‬
      ‫‪Err.Clear‬‬
   ‫‪End If‬‬
‫‪End Sub‬‬

        ‫ـ‬     ‫ـ‬        ‫ـ‬                         ‫ـ‬        ‫ـ‬        ‫ـ‬
‫واﻟﺨﻄــﻮة اﻻﺧﻴــﺮة ﺗﻐﻴﻴــﺮ ﻣﺤﺘﻮﻳــﺎت اﻻداة ‪ FileListBox‬ﺑﻤﺠــﺮد ﺗﻐﻴﻴــﺮ ﻣﺴــﺎر اﻻداة‬
                                    ‫‪ DirListBox‬وﻧﻜﻮن ﺑﺬﻟﻚ ﻗﺪ رﺑﻄﻨﺎ اﻻدوات اﻟﺜﻼث:‬

‫)(‪Private Sub Dir1_Change‬‬
   ‫‪File1.Path = Dir1.Path‬‬
‫‪End Sub‬‬

 ‫ﻳﻤﻜﻨـــﻚ آﺘﺎﺑـــﺔ اﻟﻤﺴـــﺎر ﻣﺒﺎﺷـــﺮة ﻟﻠﺨﺎﺻـــﻴﺔ ‪ Path‬اﻟﺘﺎﺑﻌـــﺔ ﻟـــﻼداة‬   ‫ﻣﻼﺣﻈﺔ:‬
                              ‫‪ DirListBox‬ﺣﺎﻟﻬﺎ آﺤﺎل اﻻداة ‪:FileListBox‬‬
 ‫"‪Dir1.Path = "C:\Windows‬‬
 ‫”‪File1.Path = "C:\Winnt‬‬

‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻼداة ‪ FileListBox‬ﻓﻬﻲ ﺗﺤﺘﻮي ﻋﻠـﻰ ﺧﺎﺻـﻴﺔ ﻣﺮﻧـﺔ ﺗـﺪﻋﻰ ‪ Pattern‬اﻟﺘـﻲ‬
‫ﺗﻤﻜﻨﻚ ﻣﻦ ﺗﺼﻔﻴﺔ اﻟﻤﻠﻔﺎت وﺗﺤﺪﻳﺪ ﻧﻮع ﻣﻌﻴﻦ ﻣﻦ اﻻﻣﺘﺪادات اﻟﺘﻲ ﺗﻈﻬﺮ ﻋﻠﻰ اﻻداة:‬

‫”‪File1.Pattern = “*.EXE‬‬
‫”‪File1.Pattern = “*.TXT;*.DOC;*.RTF‬‬
‫”*.*‪File1.Pattern = “ABC‬‬

‫اﻟﻤﺰﻳﺪ ﻣﻦ ﻋﻤﻠﻴـﺎت اﻟﺘﺼـﻔﻴﺔ ﺗﻤﻜﻨـﻚ ﻣﻨﻬـﺎ اﻟﺨﺼـﺎﺋﺺ اﻟﻤﻨﻄﻘﻴـﺔ ‪،Archive ،Normal‬‬
‫‪ ReadOnly ،Hidden‬و ‪ .System‬ﻓﻼﺧﻔــﺎء ﻣﻠﻔــﺎت اﻟﻘــﺮاءة ﻓﻘــﻂ ‪ ReadOnly‬واﻇﻬــﺎر‬
                             ‫اﻟﻤﻠﻔﺎت اﻟﻤﺨﻔﻴﺔ ‪ Hidden‬اآﺘﺐ اﻟﻜﻮد اﻟﺒﺴﻴﻂ اﻟﺘﺎﻟﻲ:‬
                                                 ‫86‬


‫‪File1.ReadOnly = False‬‬
‫‪File1.Hidden = True‬‬

                         ‫اﻣﺎ اﻟﺨﺎﺻﻴﺔ ‪ FileName‬ﻓﻬﻲ ﺗﻤﺜﻞ اﻟﻤﻠﻒ اﻟﻤﺤﺪد ﻓﻲ اﻻداة.‬

 ‫ادوات اﻟﻤﻠﻔﺎت اﻟﺜﻼﺛﺔ ﺷﺒﻴﻬﻪ ﺑﺄدوات اﻟﻘـﻮاﺋﻢ ‪ ListBox‬و ‪ComboBox‬‬              ‫ﻣﻼﺣﻈﺔ:‬
    ‫ﻓﻬﻲ ﺗﺤﺘﻮي ﻋﻠﻰ اﻟﺨﺼﺎﺋﺺ ‪ ListCount ،List‬و ‪ ListIndex‬اﻳﻀﺎ.‬


                                                                      ‫ادوات اﺧﺮى‬
‫ﻣﻦ اﻻدوات اﻻﺧﺮى اﻟﺘﻲ أود ان اﺧﺘﻢ ﺑﻬﺎ هﺬا اﻟﻔﺼﻞ هـﻲ أداة اﻻﻃـﺎر ‪ Frame‬اﻟﺘـﻲ‬
‫ﺗﺴﺘﺨﺪم ﺑﻜﺜـﺮة ﻟﺤﻀـﻦ اﻻدوات وﺗﻘﺴـﻴﻤﻬﺎ إﻟـﻰ ﻣﺠﻤﻮﻋـﺎت، وﻳﻤﻜﻨـﻚ اﻟـﺘﺤﻜﻢ ﻓـﻲ‬
  ‫ـ‬                          ‫ـ‬             ‫ـ ـ‬                ‫ـ‬   ‫ـ‬
‫ﻇﻬـﻮر او اﺧﻔـﺎء اﻟﺤـﺪ اﻟﺨـﺎرﺟﻲ ﻟﻬـﺎ ﻋـﻦ ﻃﺮﻳـﻖ اﻟﺨﺎﺻـﻴﺔ ‪ .BorderStyle‬واداة رﺳـﻢ‬
‫اﻟﺨﻄﻮط ‪ Line‬اﻟﺘﻲ ﻻ ﻳﻮﺟﺪ داﻋﻲ ﻟﺬآﺮ اﻟﺸﻜﻞ اﻟﺬي ﺗﺮﺳﻤﻪ وﻟﻜﻦ ﻣﺎ دﻋﺎﻧﻲ ﻟـﺬآﺮﻩ‬
‫هﻮ ﺧﺼﺎﺋﺺ اﻟﻤﻮﻗﻊ واﻟﺤﺠﻢ اﻟﺘﺎﺑﻌﺔ ﻟﻬـﺎ 1‪ Y1 ،X2 ،X‬و 2‪ Y‬ﻓﻬـﻲ ﻟﻴﺴـﺖ ‪،Top ،Left‬‬
‫‪ Width‬و ‪ ،Height‬وﻟﻜﻨﻬﺎ اﺣﺪاﺛﻴﺎت ﻧﻘﻄﺘﻲ اﻟﺒﺪاﻳﺔ واﻟﻨﻬﺎﻳﺔ ﻟﻠﺨـﻂ اﻟـﺬي ﺗﺮﻳـﺪ رﺳـﻤﺔ‬
‫اﻣﺎ اداة رﺳﻢ اﻻﺷﻜﺎل ‪ Shape‬ﻓﺘﺴﺘﺨﺪم ﻟﺮﺳﻢ ﺷـﻜﻞ ﻣـﻦ ﺑـﻴﻦ 6 اﺷـﻜﺎل ﻣﺨﺘﻠﻔـﺔ‬
‫ﺗﺴﺘﻄﻴﻊ ﺗﺤﺪﻳﺪهﺎ ﻋﻦ ﻃﺮﻳﻖ اﻟﺨﺎﺻﻴﺔ اﻟﺘﻲ ﺗﺤﻤﻞ ﻧﻔـﺲ اﺳـﻢ اﻻداة. وأداة اﻟﻤﺆﻗـﺖ‬
‫‪ Timer‬اﻟﺘﻲ ﺗﻤﻜﻨﻚ ﻣﻦ ﺗﻨﻔﻴﺬ اﻻواﻣﺮ اﻟﻤﻮﺟﻮدة ﻓﻲ ﺣـﺪﺛﻬﺎ اﻟﻮﺣﻴـﺪ ‪ Timer‬آـﻞ ﻓﺘـﺮة‬
‫ﻣﻌﻴﻨﺔ، ﺗﺤﺪﻳﺪ هﺬﻩ اﻟﻔﺘﺮة ﺗﻀﻌﻪ ﻓﻲ اﻟﺨﺎﺻﻴﺔ ‪ Interval‬ووﺣﺪﺗﻬﺎ 100.0 ﺛﺎﻧﻴﺔ. اﻣﺎ أداة‬
‫رﺑﻂ اﻟﻜﺎﺋﻨﺎت وﺗﻀﻤﻴﻨﻬﺎ ‪ OLE‬ﻓﻬﻲ ﺗﻤﻜﻨﻚ ﻣﻦ اﺳﺘﺨﺪام ﺗﻘﻨﻴﺔ ‪ OLE‬ﻟﻮﺿـﻊ ﻣﺴـﺘﻨﺪات‬
‫ﻣﺨﺘﻠﻔﺔ ﻣﻦ ﺗﻄﺒﻴﻘﺎت ﻣﺨﺘﻠﻔﺔ ﻓﻲ ﻧﺎﻓﺬة اﻟﻨﻤﻮذج. اﻟﺘﺤﺪث ﻋﻦ ﺗﻔﺎﺻﻴﻞ اﻻداة او ﺗﻘﻨﻴﺔ‬
                                                    ‫‪ OLE‬ﺧﺎرج ﻧﻄﺎق هﺬا اﻟﻜﺘﺎب.‬

     ‫ـ‬               ‫ـ‬         ‫ـ ـ‬
 ‫ﻻ ﺗﺤ ـﺎول اﻻآﺜ ـﺎر ﻣ ـﻦ اﻻآ ـﻮاد اﻟﻄﻮﻳﻠ ـﺔ ﺑ ـﺪاﺧﻞ اﻟﺤ ـﺪث ‪ Timer‬ﻟ ـﻸداة‬
                                             ‫ـ‬     ‫ـ‬     ‫ـ‬         ‫ـ‬        ‫ﻣﻼﺣﻈﺔ:‬
 ‫‪ Timer‬ﻓﺬﻟﻚ ﻳﺴﺒﺐ اﺳﺘﻬﻼك آﺒﻴﺮ ﻟﻠﻤﻌﺎﻟﺠﺔ ‪ Processing‬ﻣﻦ ﻣﺼﺎدر‬
   ‫ـ‬        ‫ـ‬       ‫ـ‬     ‫ـ‬       ‫ـ ـ‬
 ‫اﻟﻨﻈـﺎم ‪ System Resources‬ﻣﻤ ـﺎ ﻳـﺆدي اﻟ ـﻰ اﺑﻄـﺎء ﺗﻨﻔﻴ ـﺬ ﺑﺮاﻣﺠ ـﻚ‬  ‫ـ‬
                                  ‫واﻟﺒﺮاﻣﺞ اﻻﺧﺮى ﻓﻲ ﻧﻈﺎم اﻟﺘﺸﻐﻴﻞ.‬
                                               ‫96‬


‫اﺧﻴﺮا وﻣﻊ ﻧﻬﺎﻳﺔ هﺬا اﻟﻔﺼﻞ، ﺑﻮدي ﻋﺮض هﺬﻩ اﻟﻤﻼﺣﻈﺔ اﻟﺘﻲ آﺘﺒﻬﺎ اﻻﺳـﺘﺎذ ﺳـﺎﻟﻢ‬
              ‫اﻟﻤﺎﻟﻜﻲ ﻋﻨﺪ ﻣﺮاﺟﻌﺘﻪ ﻟﻬﺬا اﻟﻔﺼﻞ ﺣﻮل اﻟﺘﻌﺒﻴﺮ "اﻧﻔﺠﺎر اﻻﺣﺪاث" :‬

         ‫ﻣﻼﺣﻈﺔ اﺧﻴﺮة: ﻗﺮأت ﻓﻲ هﺬا اﻟﻔﺼﻞ ﻣﻦ اﻻﻧﻔﺠﺎرت ﻣﺎ ﻳﻜﻔﻲ ﻟﻔﻨﺎء اﻟﺒﺸﺮﻳﺔ!‬
‫اﻗﺘــﺮح ﻋﻠﻴــﻚ ﺑﺸــﺪة اﺳــﺘﺒﺪاﻟﻪ ﺑﺄﺣــﺪ اﻟﻌﺒــﺎرات )اﻃــﻼق/اﻧﻄــﻼق اﻟﺤــﺪث(/)ﺗﻨﻔﻴــﺬ‬
‫اﻟﺤــﺪث(/)ﺗﺸــﻐﻴﻞ اﻟﺤــﺪث(. وﻷﻧــﻲ اﻋﻠــﻢ أن اﻟﻘﻀــﻴﺔ هــﻲ ﻗﻨﺎﻋــﺔ ﺧﺎﺻــﺔ ﻓــﺈﻧﻲ ﻻ‬
                                  ‫اﺳﺘﻄﻴﻊ أن اﻓﺮض ﻋﻠﻴﻚ رأﻳﻲ. وﺳﺄﺣﺘﺮم اﺧﺘﻴﺎرك.‬
‫اﻣﺎ إن واﻓﻘﺖ ﻋﻠﻰ اﻟﺘﻐﻴﻴﺮ وآﻨﺖ ﺗﺮﻳﺪ ﻣﻨﻲ اﻟﻤﺴﺎهﻤﺔ ﻓﻲ ذﻟﻚ ﻓﻼ ﻣـﺎﻧﻊ ﻟـﺪي، ﻣـﻦ‬
                                              ‫اﻟﻤﺸﺎرآﺔ ﻓﻲ رﻓﻊ آﻞ هﺬﻩ اﻻﻟﻐﺎم!!!‬

                                                                      ‫ووﺳﻊ ﺻﺪرك.‬
                                                 ‫07‬


                                        ‫اﻟﻔﺼﻞ اﻟﺜﺎﻟﺚ‬
                          ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ ‪BASIC‬‬


‫ان ‪ Visual Basic‬ﺷﺨﺼﻴﺔ اﺻﻴﻠﺔ ﻣﻌﺘﺰة ﺑﺎﻣﺠﺎدهﺎ وﺗﺎرﻳﺨﻬـﺎ، ﻓﻤـﺎ زاﻟـﺖ ‪Visual Basic‬‬
‫ﻣﺤﺘﻔﻈﺔ ﺑﺴﻤﺎت ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ ‪ BASIC‬اﻟﺘﻲ ﺗﺼـﻨﻒ ﻣـﻦ ﻟﻐـﺎت اﻟﺒﺮﻣﺠـﺔ اﻟﻌﻠﻴـﺎ ‪High‬‬
‫‪ ،level programming language‬ﻟﻐﺔ ‪ BASIC‬هـﻲ روح ﻟﻐـﺔ اﻟﺒﺮﻣﺠـﺔ ‪،Visual Basic‬‬
‫وهﻲ اﻟﻠﻐﺔ اﻟﺘﻲ زادت ﻣﻦ اﺳﻬﻢ وﺷﻌﺒﻴﺔ ‪ Visual Basic‬اﻟﻰ ﺟﺎﻧﺐ ﻣﺼـﻤﻢ اﻟﻨﻤـﺎذج‬
‫‪ .Form Designer‬ﻓﻤﻌﻈﻢ اﻟﺼﻴﻎ ‪ Syntax‬اﻟﺘﻲ ﻇﻬﺮت ﺑﻬﺎ اﻟﻠﻐﺔ ﻣﻨﺬ ﺑﺪاﻳـﺔ اﻟﺴـﺘﻴﻨﺎت‬
‫ﻣﺎزاﻟﺖ ﻣﺪﻋﻮﻣﺔ ﺑﺸﻜﻞ ﺟﻴﺪ ﻓﻲ اﺣﺪث اﺻﺪارات ‪ .Visual Basic‬ﻟﻴﺲ هـﺬا ﻓﻘـﻂ، ﺑـﻞ‬
‫اﺿﻴﻔﺖ اﻟﻴﻬﺎ اﻟﻌﺸﺮات ﻣﻦ اﻟـﺪوال واﻟﺼـﻴﻎ اﻟﺒﺮﻣﺠﻴـﺔ ﺣﺘـﻰ ﺗﻼﺋـﻢ ﻗـﻮة ‪Visual Basic‬‬
                                       ‫وﺗﺤﺎآﻲ ﺗﻄﺒﻴﻘﺎت ‪ Windows‬ﻓﻲ اﻣﻜﺎﻧﻴﺎﺗﻬﺎ.‬


                                                                ‫اﻟﻤﺘﻐﻴﺮات واﻟﺜﻮاﺑﺖ‬
‫اﻟﻤﺘﻐﻴﺮات واﻟﺜﻮاﺑﺖ هﻲ اﺳﺎس أي ﻟﻐـﺔ ﺑﺮﻣﺠـﺔ. إن اﺳـﺘﻴﻌﺎب اﻧـﻮاع اﻟﻤﺘﻐﻴـﺮات ﻣـﻦ‬
‫اﻟﻤﺴــﺎﺋﻞ اﻟﻀــﺮورﻳﺔ اﻟﺘــﻲ ﺗﻤﻜﻨــﻚ ﻣــﻦ اﺧﺘﻴــﺎر اﻻﻧــﻮاع اﻟﻤﻨﺎﺳــﺒﺔ ﻟﻠﻤﺘﻐﻴــﺮات ﺳــﻮاء‬
‫ﻻرﺳﺎﻟﻬﺎ اﻟﻰ اﻟﺪوال او ﻹﺟﺮاء اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﺔ ﻋﻠﻴﻬـﺎ. ﺑـﻮدي اﻟﺘﺤـﺪث ﻋـﻦ ﻣﺒـﺪﺋﺎ‬
                        ‫ﻗﺎﺑﻠﻴﺔ اﻟﺮؤﻳﺔ وﻋﻤﺮ اﻟﺤﻴﺎة ﻗﺒﻞ اﻟﺨﻮض ﻓﻲ ﺗﻔﺎﺻﻴﻞ اﻟﻤﺘﻐﻴﺮات.‬

                                                  ‫ﻗﺎﺑﻠﻴﺔ اﻟﺮؤﻳﺔ وﻋﻤﺮ اﻟﺤﻴﺎة‬
‫ﻗﺎﺑﻠﻴﺔ اﻟﺮؤﻳﺔ وﻋﻤﺮ اﻟﺤﻴﺎة ﻣﻦ اﺣـﺪ اﻟﻤﺒـﺎدئ اﻟﻀـﺮورﻳﺔ ﻓـﻲ ﺟﻤﻴـﻊ ﻟﻐـﺎت اﻟﺒﺮﻣﺠـﺔ، و‬
                       ‫‪ Visual Basic‬ﻳﻌﺘﺒﺮ ﻟﻐﺔ ﺑﺮﻣﺠﺔ ﺣﻘﻴﻘﺔ ﺗﺪﻋﻢ هﺬان اﻟﻤﺒﺪﺋﺎن.‬
‫ﻗﺎﺑﻠﻴﺔ اﻟﺮؤﻳﺔ ‪– Visibility‬او اﻟﻤﺪى ‪ -Scope‬ﻟﻠﻤﺘﻐﻴﺮ ﺗﻤﺜﻞ ﻗﺪرة اﻟﺒﺮﻧﺎﻣﺞ ﻋﻠﻰ اﻟﻮﺻـﻮل‬
‫اﻟﻰ اﻟﻤﺘﻐﻴﺮ واﺳﺘﺨﺪاﻣﻪ، ﻓﺎﻟﻤﺘﻐﻴﺮ ‪ X‬اﻟﻤﻮﺟﻮد ﻓﻲ اﻟﻜﻮد اﻟﺘﺎﻟﻲ ﻻ ﻳﻤﻜﻦ اﻟﻮﺻﻮل اﻟﻴـﻪ‬
                                                         ‫ﺧﺎرج اﻻﺟﺮاء 1‪:MySub‬‬

‫)( 1‪Sub MySub‬‬
      ‫‪Dim X As Integer‬‬
      ‫02 = ‪X‬‬
                                              ‫17‬


‫‪End Sub‬‬

‫)( 2‪Sub MySub‬‬
      ‫‪Print X‬‬         ‫ﻻ ﻳﻤﺜﻞ اﻟﻤﺘﻐﻴﺮ ‪ X‬اﻟﺴﺎﺑﻖ ‘‬
‫‪End Sub‬‬

‫اﻣﺎ ﻋﻤﺮ اﻟﺤﻴﺎة ‪ LifeTime‬ﻟﻠﻤﺘﻐﻴﺮ، ﻓﻬﻲ ﺗﻤﺜﻞ اﻟﻔﺘﺮة اﻟﺘﻲ ﻳﻈﻞ ﻓﻴﻬﺎ اﻟﻤﺘﻐﻴﺮ ﻣﺤﺘﻔﻈﺎ‬
‫ﺑﻘﻴﻤﺘﻪ، ﻓﺎﻟﻤﺘﻐﻴﺮ ‪ X‬اﻟﻤﻮﺟﻮد ﻓﻲ اﻟﻜﻮد اﻟﺴﺎﺑﻖ، ﺳﻴﻨﺘﻬﻲ وﻳﺰال ﺗﻠﻘﺎﺋﻴـﺎ ﻣـﻦ اﻟـﺬاآﺮة‬
‫ﺑﻤﺠﺮد اﻟﺨﺮوج ﻣﻦ اﻻﺟـﺮاء 1‪ .Sub‬وﻟﻜـﻲ ﺗﻔﻬـﻢ اﻻﺳـﻠﻮب اﻟـﺬي ﻳﺘﺒﻌـﻪ ‪Visual Basic‬‬
‫ﻟﺘﻄﺒﻴﻖ ﻣﺒﺪأ ﻗﺎﺑﻠﻴﺔ اﻟﺮؤﻳﺔ وﻋﻤﺮ اﻟﻤﺘﻐﻴﺮات، ﻋﻠﻴﻚ ﻣﻌﺮﻓﺔ اﻧﻮاع اﻟﻤﺘﻐﻴﺮات ﻣـﻦ ﻣﻨﻈـﻮر‬
                                                             ‫اﻟﺮؤﻳﺔ وﻋﻤﺮ اﻟﺤﻴﺎة:‬

                                                ‫اﻟﻤﺘﻐﻴﺮات اﻟﻤﺤﻠﻴﺔ اﻟﺪﻳﻨﺎﻣﻴﻜﻴﺔ:‬
‫اﻟﻤﺘﻐﻴﺮات اﻟﻤﺤﻠﻴﺔ اﻟﺪﻳﻨﺎﻣﻴﻜﻴـﺔ ‪ Dynamic Local Variables‬هـﻲ ﻣﺘﻐﻴـﺮات ﺗﻮﻟـﺪ ﻣـﻊ‬
‫اﻟﺴﻄﺮ اﻟﺬي ﺗﻌﻠﻦ ﻋﻨﻬﺎ ﻓﻴﻪ داﺧﻞ اﻻﺟـﺮاء وﺗﻤـﻮت ﺑﻌـﺪ ﻧﻬﺎﻳـﺔ اﻻﺟـﺮاء ﻣﺒﺎﺷـﺮة وﻳـﺘﻢ‬
‫ﺗﺤﺮﻳﺮ اﻟﻤﺴﺎﺣﺔ اﻟﺘﻲ ﺣﺠﺰﺗﻬﺎ هﺬﻩ اﻟﻤﺘﻐﻴﺮات ﻓﻲ اﻟﺬاآﺮة، وﺑﺎﻟﻨﺴـﺒﺔ ﻟﻘﺎﺑﻠﻴـﺔ اﻟﺮؤﻳـﺔ‬
‫ﻓﻠﻦ ﺗﺴﺘﻄﻴﻊ اﻟﻮﺻﻮل اﻟﻰ هﺬﻩ اﻟﻤﺘﻐﻴﺮات اﻟـﻰ ﻓـﻲ ﻧﻔـﺲ اﻻﺟـﺮاء اﻟـﺬي ﺻـﺮح ﻓﻴـﻪ‬
    ‫اﻟﻤﺘﻐﻴﺮ. ﺗﺴﺘﺨﺪم اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ Dim‬ﻟﺘﺼﺮﻳﺢ اﻟﻤﺘﻐﻴﺮ ﻣﻊ آﺘﺎﺑﺔ اﺳﻤﻪ وﻧﻮﻋﻪ:‬

‫‪Dim sName As String‬‬
‫‪Dim iAge As Integer‬‬

‫اذا آﺎﻧﺖ اﻟﻜﻠﻤـﺔ اﻟﻤﺤﺠـﻮزة ‪ Option Explicit‬ﻣﻮﺟـﻮدة ﻓـﻲ اﻋﻠـﻰ ﻣﻨﻄﻘـﺔ اﻻﻋﻼﻧـﺎت‬
‫اﻟﻌﺎﻣﺔ ﻟﻨﺎﻓـﺬة اﻟﻨﻤـﻮذج او ﻣﻠـﻒ اﻟﺒﺮﻣﺠـﺔ ‪ ،BAS‬ﻓﻌﻠﻴـﻚ اﻟﻼﻟﺘـﺰام ﺑﺎﻟﺘﺼـﺮﻳﺢ آﻤـﺎ ﻓـﻲ‬
‫اﻟﺼﻴﻐﺔ اﻟﺴﺎﺑﻘﺔ، وان ﻟﻢ ﺗﻜﻦ اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠـﻮزة ‪ Option Explicit‬ﻣﺴـﻄﻮرة ﻓﻴﻤﻜﻨـﻚ‬
       ‫ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮ ﻣﺒﺎﺷﺮة دون اﻻﻟﺘﺰام ﺑﻌﻤﻠﻴﺔ اﻟﺘﺼﺮﻳﺢ ﺑﺎﺳﻨﺎد ﻗﻴﻤﺔ اﺑﺘﺪاﺋﻴﺔ ﻟﻪ:‬

‫”ﺗﺮآﻲ اﻟﻌﺴﻴﺮي“ = ‪sName‬‬
‫99 = ‪iAge‬‬

‫ﺻﺤﻴﺢ ان اﻟﻜﻮد اﻟﺴﺎﺑﻖ ﻳﻮﻓﺮ ﻋﻠﻴﻚ ﻋﻨﺎء ﺗﺼﺮﻳﺢ اﻟﻤﺘﻐﻴﺮ ﻻ اﻧﻪ ﻏﻴﺮ ﻣﺤﺒﺬ ﺑﺸﻜﻞ آﺒﻴـﺮ‬
                   ‫ﻟﺪى اﻟﻤﺒﺮﻣﺠﻴﻦ اﻟﺠﺎدﻳﻦ، ﻗﺪ ﻳﻌﺮض هﺬا اﻟﻤﺜﺎل اﺣﺪ اﻻﺳﺒﺎب:‬

‫”اﻟﺸﺮآﺔ اﻟﺘﺠﺎرﻳﺔ“ = ‪sCompanyName‬‬
‫اﻟﻨﺎﺗﺞ 0 ‘ ‪Print sConpanyName‬‬
                                                   ‫27‬


‫اﻟﻨﺎﺗﺞ ﻣﻦ ﻋﻤﻠﻴﺔ اﻟﻄﺒﺎﻋﺔ ‪ Print‬ﻓﻲ اﻟﻜﻮد اﻟﺴﺎﺑﻖ ﻟﻦ ﻳﻜﻮن آﻤﺎ هﻮ ﻣﺘﻮﻗﻊ "اﻟﺸـﺮآﺔ‬
     ‫ـ‬                     ‫ـ‬       ‫ـ‬
‫اﻟﺘﺠﺎرﻳـﺔ"، ﻓ ـﺎﻟﻤﺘﻐﻴﺮ اﻟﻤﺴـﺘﺨﺪم ﻓ ـﻲ اﻟﺴ ـﻄﺮ اﻟﺜـﺎﻧﻲ ه ـﻮ ‪ sConpanyName‬وﻟ ـﻴﺲ‬
                                          ‫ـ‬      ‫ـ‬       ‫ـ‬            ‫ـ‬    ‫ـ‬
 ‫‪ sCompanyName‬وهﺬا اﻟﺨﻄﺄ آﻔﻴﻞ ﻓﻲ ﻧﻤﻮ اﻟﺸﻮاﺋﺐ اﻟﺒﺮﻣﺠﻴﺔ ‪ Bugs‬ﻓﻲ ﺑﺮاﻣﺠﻚ.‬
‫ﺳﺒﺐ ﺁﺧﺮ ﻗﺪ ﻳﺠﻌﻠﻚ ﺗﺤﺒﺬ اﻻﻟﺘﺰام ﺑﻌﻤﻠﻴﺔ اﻟﺘﺼـﺮﻳﺢ وهـﻮ ان ﺟﻤﻴـﻊ اﻟﻤﺘﻐﻴـﺮات ﺗﻜـﻮن‬
‫ﻣﻦ اﻟﻨﻮع ‪ Variant‬ان ﻟﻢ ﻳﺘﻢ ﺗﺼـﺮﻳﺢ ﻧـﻮع ﻏﻴـﺮ ذﻟـﻚ، واﻟﻨـﻮع ‪ Variant‬هـﻮ اﺑﻄـﺄ اﻧـﻮاع‬
                                                       ‫اﻟﻤﺘﻐﻴﺮات آﻤﺎ ﺳﻴﺄﺗﻲ ﻻﺣﻘﺎ.‬
‫ﻓﻲ ﻣﺜﺎﻟﻨﺎ اﻟﺴﺎﺑﻖ؛ ﻳﺆدي ﻓﺮض اﻻﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ‪ Option Explicit‬إﻟﻰ اﻻﻋـﻼن‬
‫ﻋﻦ ﺧﻄﺄ و ﺗﻮﻗﻒ اﻟﺒﺮﻧﺎﻣﺞ. وﻓﻲ ﺟﻤﻴﻊ اﻟﺤﺎﻻت ﻓﺈن اﻟﺨﻄﺄ ﻓﻲ آﺘﺎﺑﺔ اﺳـﻢ اﻟﻤﺘﻐﻴـﺮ أو‬
                               ‫ﺎ‬
‫اﺳﻨﺎد ﻗﻴﻤﺔ إﻟﻰ ﻣﺘﻐﻴﺮات ﻟﻢ ﻳﺘﻢ اﻻﻋﻼن ﻋﻨﻬﺎ ﻣﺴﺒﻘً ﺳﻴﺘﺘﺴﺒﺐ ﻓﻲ اﻹﻋـﻼن ﻋـﻦ‬
                                                       ‫ﺎ‬
                                                      ‫ﺧﻄﺄ، وﺳﻴﺘﻮﻗﻒ اﻟﺒﺮﻧﺎﻣﺞ اﻳﻀً.‬

 ‫ﺗﻮﻓﺮ ﻟﻚ ﺑﻴﺌﺔ اﻟﺘﻄﻮﻳﺮ اﻟﻤﺘﻜﺎﻣﻠﺔ ‪ IDE‬ﺧﻴﺎر ﻳﻠﺰﻣﻚ ﺑﻌﻤﻠﻴـﺔ اﻟﺘﺼـﺮﻳﺢ أي‬             ‫ﻣﻼﺣﻈﺔ:‬
 ‫ﺑﻜﺘﺎﺑﺔ اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ Option Explicit‬ﻓﻲ ﺟﻤﻴﻊ وﺣﺪات ﺑﺮاﻣﺠـﻚ‬
 ‫آﻨﻮاﻓــﺬ اﻟﻨﻤــﺎذج، ﻣﻠﻔــﺎت اﻟﺒﺮﻣﺠــﺔ .... اﻟــﺦ. ﻟﺘﻔﻌﻴــﻞ اﻻﺧﺘﻴــﺎر، ﺣــﺪد‬
 ‫اﻻﺧﺘﻴـﺎر ‪ Require Variable Declaration‬ﻣـﻦ ﺧﺎﻧـﺔ اﻟﺘﺒﻮﻳـﺐ ‪Editor‬‬
                                             ‫ﻓﻲ ﺻﻨﺪوق اﻟﺤﻮار ‪.Options‬‬

‫اﺧﻴﺮا، اﻟﻘﻴﻤﺔ اﻻﺑﺘﺪاﺋﻴﺔ ﻟﻠﻤﺘﻐﻴﺮ اﻟﻌﺪدي اﻟﻤﺼﺮح هﻲ 0، واﻟﺤﺮﻓﻲ ﻳﻜﻮن ﻗﻴﻤﺔ ﺣﺮﻓﻴـﺔ‬
                                ‫ﺧﺎﻟﻴﺔ ""، اﻣﺎ اﻟﻜﺎﺋﻨﺎت ﻓﻬﻲ ﻻ ﺷﺊ ‪.Nothing‬‬

                                             ‫اﻟﻤﺘﻐﻴﺮات اﻟﻤﺤﻠﻴﺔ اﻟﺴﺘﺎﺗﻴﻜﻴﺔ:‬
  ‫ـ‬     ‫ـ‬                               ‫ـ‬       ‫ـ‬         ‫ـ‬        ‫ـ‬       ‫ـ‬
‫ﻗﺎﺑﻠﻴـﺔ اﻟﺮؤﻳـﺔ ﻟﻠﻤﺘﻐﻴـﺮات اﻟﻤﺤﻠﻴـﺔ اﻟﺴـﺘﺎﺗﻴﻜﻴﺔ ‪ Static Local Variables‬هـﻲ ﻣﺜـﻞ‬
‫ﻗﺎﺑﻠﻴﺔ اﻟﺮؤﻳﺔ ﻟﻠﻤﺘﻐﻴﺮات اﻟﻤﺤﻠﻴﺔ اﻟﺪﻳﻨﺎﻣﻴﻜﻴﺔ أي ﻟﻦ ﺗﺘﻤﻜﻦ ﻣﻦ اﻟﻮﺻـﻮل اﻟﻴﻬـﺎ اﻻ ﻣـﻦ‬
‫داﺧﻞ اﻻﺟﺮاء اﻟﻤﺼﺮح ﻋﻨﻬﺎ ﻓﻴﻪ، وﺑﺎﻟﻨﺴﺒﺔ ﻟﻌﻤﺮ ﺣﻴﺎة اﻟﻤﺘﻐﻴﺮ اﻻﺳﺘﺎﺗﻴﻜﻲ ﻓﻬﻮ ﻳﻴﺒﻘﻰ‬
‫ﻣﺤﺘﻔﻈﺎ ﺑﻘﻴﻤﺘﻪ ﺣﺘﻰ ﻧﻬﺎﻳﺔ اﻟﺒﺮﻧﺎﻣﺞ اذا آـﺎن ﻓـﻲ ﻣﻠـﻒ ﺑﺮﻣﺠـﺔ ‪ BAS‬او ﺣﺘـﻰ ﻳﻤـﻮت‬
‫اﻟﻜﺎﺋﻦ اﻟﺘﺎﺑﻊ ﻟﻪ. ﻟﺘﺼﺮﻳﺢ ﻣﺘﻐﻴﺮ ﺳـﺘﺎﺗﻴﻜﻲ اﺳـﺘﺨﺪم اﻟﻜﻠﻤـﺔ اﻟﻤﺤﺠـﻮزة ‪ Static‬ﻋﻮﺿـﺎ‬
                                                                     ‫ﻋﻦ ‪:Dim‬‬

‫‪Static bStaticVariable As Boolean‬‬

‫ﺗﺴــﺘﻄﻴﻊ ﺟﻌــﻞ ﺟﻤﻴــﻊ اﻟﻤﺘﻐﻴــﺮات اﻟﺘﺎﺑﻌــﺔ ﻟﻼﺟــﺮاء ﺳــﺘﺎﺗﻴﻜﻴﺔ ﺑﻮﺿــﻊ ﻧﻔــﺲ اﻟﻜﻠﻤــﺔ‬
                                                           ‫اﻟﻤﺤﺠﻮزة ﻋﻨﺪ ﺑﺪاﻳﺔ اﻻﺟﺮاء:‬
                                                ‫37‬


‫)( ‪Static Sub Counter‬‬
        ‫ﺟﻤﻴﻊ اﻟﻤﺘﻐﻴﺮات اﻟﺘﺎﻟﻴﺔ ﺳﺘﺎﺗﻴﻜﻴﺔ ‘‬
        ‫‪Dim iCounter As Integer‬‬
        ‫‪Dim iCounter2 As Integer‬‬
        ‫…‬
‫‪End Sub‬‬

‫ﻻ ﺗﺤﺎول ﺗﻄﺒﻴﻖ اﻟﻜﻮد اﻟﺴـﺎﺑﻖ آﺜﻴـﺮا، ﻓـﺎﻟﻤﺘﻐﻴﺮات اﻟﺴـﺘﺎﺗﻴﻜﻴﺔ اﺑﻄـﺄ ﻣـﻦ اﻟﻤﺘﻐﻴـﺮات‬
‫اﻟﺪﻳﻨﺎﻣﻴﻜﻴﺔ اﻟﻰ ﺟﺎﻧﺐ ﻗﻴﺎﻣﻬﺎ ﺑﺤﺠﺰ ﻣﻮاﻗﻊ هـﺬﻩ اﻟﻤﺘﻐﻴـﺮات ﻓـﻲ اﻟـﺬاآﺮة ﻃـﻮال ﻓﺘـﺮة‬
‫ﻋﻤﻞ اﻟﺒﺮﻧﺎﻣﺞ، ﻓﻼ ﺗﺤﺎول اﺳﺘﺨﺪاﻣﻬﺎ اﻻ ﻋﻨﺪ اﻟﺤﺎﺟﺔ آﺎﻟﺮﻏﺒﺔ ﻓﻲ ﺗﻨﻔﻴﺬ اﺟـﺮاء ﻣﻌـﻴﻦ‬
                              ‫ﻟﻤﺮة واﺣﺪة ﻣﺜﻼ او اﻻﺣﺘﻔﺎظ ﺑﻘﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ﻓﻲ ﻋﺪاد:‬

‫)( ‪Sub PrintData‬‬
       ‫‪Static bIsPrinting As Boolean‬‬

      ‫‪If bIsPrinting Then‬‬
              ‫‪Exit Sub‬‬
      ‫‪Else‬‬
              ‫‪bIsPrinting = True‬‬
      ‫‪End If‬‬
      ‫…‬
‫‪End Sub‬‬

‫)( ‪Sub Counter‬‬
      ‫‪Static iCounter As Integer‬‬

      ‫1 + ‪iCounter = iCounter‬‬
‫‪End Sub‬‬

   ‫ـ‬     ‫ـ ـ‬              ‫ـ‬
‫اﺧﻴ ـﺮا، اﻟﻜﻠﻤ ـﺔ اﻟﻤﺤﺠـﻮزة ‪ Static‬ﻻ ﺗﻄﺒـﻖ اﻻ ﻋﻠ ـﻰ اﻟﻤﺘﻐﻴ ـﺮات اﻟﻤﺤﻠﻴ ـﺔ ﻓ ـﻼ ﺗﺤ ـﺎول‬
                                    ‫ـ‬        ‫ـ‬                ‫ـ‬       ‫ـ‬          ‫ـ‬
 ‫اﺳﺘﺨﺪاﻣﻬﺎ ﻋﻠﻰ ﻣﺘﻐﻴﺮات ﻋﺎﻣﺔ او ﻋﻠﻰ ﻣﺴﺘﻮى اﻟﻮﺣﺪة ﻓﻬﻲ ﺑﻄﺒﻴﻌﺘﻬﺎ ﺳﺘﺎﺗﻴﻜﻴﺔ.‬

                                              ‫اﻟﻤﺘﻐﻴﺮات ﻋﻠﻰ ﻣﺴﺘﻮى اﻟﻮﺣﺪة:‬
‫ﻻ اﻗﺼﺪ ﺑﺎﻟﻮﺣﺪة اﺗﺤﺎد اﻟﺠﻤﺎﻋﺔ او ﻧﺎدي اﻟﻮﺣﺪة اﻟﺮﻳﺎﺿﻲ، ﺑﻞ اﻗﺼﺪ اﻟﻮﺣـﺪة اﻟﺒﺮﻣﺠﻴـﺔ‬
‫‪ Module‬اﻟﻤﺘﻤﺜﻠﺔ ﻓﻲ ﻣﻠﻒ ﺑﺮﻣﺠﺔ ‪ BAS‬او ﻧﺎﻓﺬة ﻧﻤﻮذج ‪ Form‬او ﻓﺌـﺔ ‪ .... Class‬اﻟـﺦ‬
                                              ‫47‬


‫ﻣﻦ اﻟﻮﺣﺪات اﻟﻤﻜﻮﻧﺔ ﻟﻠﻤﺸﺮوع. ﻳﻤﻜﻨـﻚ ﺗﺼـﺮﻳﺢ ﻣﺘﻐﻴـﺮ ﻋﻠـﻰ ﻣﺴـﺘﻮى اﻟﻮﺣـﺪة ﻓـﻲ‬
                               ‫ﻣﻨﻄﻘﺔ اﻻﻋﻼﻧﺎت اﻟﻌﺎﻣﺔ ﻟﻠﻮﺣﺪة أي ﺧﺎرج اﻻﺟﺮاءات.‬
‫ﻗﺎﺑﻠﻴﺔ اﻟﺮؤﻳﺔ ﻟﻬﺬا اﻟﻨﻮع ﻣـﻦ اﻟﻤﺘﻐﻴـﺮات ﻳﻜـﻮن ﻋـﺎم ﻟﺠﻤﻴـﻊ اآـﻮاد اﻟﻮﺣـﺪة ﻓـﻲ ﺣﺎﻟـﺔ‬
                                      ‫اﺳﺘﺨﺪام اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ Dim‬او ‪:Private‬‬

‫‪Dim sName As String‬‬
‫‪Dim iAge As Integer‬‬

‫)( ‪Sub SetData‬‬
       ‫”ﺗﺮآﻲ اﻟﻌﺴﻴﺮي“ = ‪sName‬‬
       ‫99 = ‪iAge‬‬
‫‪End Sub‬‬

‫)( ‪Sub PrintData‬‬
       ‫‪Print sName‬‬
       ‫‪Print iAge‬‬
‫‪End Sub‬‬

‫اﻣﺎ اذا آﻨﺖ ﺗﺮﻳﺪ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴـﺮات ﻋﺎﻣـﺔ ﻗﺎﺑﻠـﺔ ﻟﻠﻮﺻـﻮل ﻣـﻦ ﺟﻤﻴـﻊ اﻧﺤـﺎء اﻟﻤﺸـﺮوع،‬
                                         ‫ﻓﺎﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ Public‬ﺗﻔﻲ ﺑﺎﻟﻐﺮض:‬

‫ﻓﻲ ﻣﻠﻒ ﺑﺮﻣﺠﺔ ‪‘ BAS‬‬
‫‪Public iNumberOfUsers As Integer‬‬

‫ﻓﻲ ﻧﺎﻓﺬة ﻧﻤﻮذج 1‪‘ Form‬‬
‫‪Public sCurrentUser As String‬‬

‫ﻓﻲ ﻧﺎﻓﺬة اﻟﻨﻤﻮذج 2‪‘ Form‬‬
‫)(‪Private Sub Form_Load‬‬
   ‫‪If iNumberOfUsers <= 0 Then‬‬
       ‫‪Exit Sub‬‬
   ‫‪Else‬‬
       ‫‪Me.Caption = Form1.sCurrentUser‬‬
   ‫‪End If‬‬
‫‪End Sub‬‬
                                                  ‫57‬


     ‫ـ‬      ‫ـ‬      ‫ـ‬
 ‫ﺑﺎﻟﻨﺴ ـﺒﺔ ﻟﻠﻜﻠﻤ ـﺔ اﻟﻤﺤﺠ ـﻮزة ‪ Global‬ﻓﻬ ـﻲ ﻣﺎزاﻟ ـﺖ ﻣﻮﺟ ـﻮدة ﻟﻀ ـﻤﺎن‬
                            ‫ـ‬              ‫ـ‬        ‫ـ‬         ‫ـ‬              ‫ﻣﻼﺣﻈﺔ:‬
 ‫اﻟﺘﻮاﻓﻘﻴﺔ ﻣﻊ اﻻﺻﺪارات اﻟﻘﺪﻳﻤﺔ ﻟـ ‪ ،Visual Basic‬وهﻲ ﺗـﺆدي ﻧﻔـﺲ‬
 ‫ﻏﺮض اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ ،Public‬وﻟﻜﻨﻚ ﻟـﻦ ﺗﺴـﺘﻄﻴﻊ اﺳـﺘﺨﺪاﻣﻬﺎ اﻻ‬
                                      ‫ﻓﻲ ﻣﻠﻔﺎت اﻟﺒﺮﻣﺠﺔ ‪ BAS‬ﻓﻘﻂ.‬

‫اﻣﺎ ﻋﻤﺮ اﻟﺤﻴﺎة ﻟﻬﺬا اﻟﻨﻮع ﻣﻦ اﻟﻤﺘﻐﻴﺮات ﻓﻴﻜﻮن ﻣﺮاﻓـﻖ ﻟﻌﻤـﺮ ﺣﻴـﺎة اﻟﻜـﺎﺋﻦ اﻟﺘـﺎﺑﻊ ﻟـﻪ‬
‫واﻟﻤﺼــﺮح ﻓﻴــﻪ –آﻌﻤــﺮ ﺣﻴــﺎة اﻟﻤﺘﻐﻴــﺮات اﻟﺴــﺘﺎﺗﻴﻜﻴﺔ، وﺑﺎﻟﻨﺴــﺒﺔ ﻟﻠﻤﺘﻐﻴــﺮات اﻟﻌﺎﻣــﺔ‬
‫اﻟﻤﺼﺮﺣﺔ ﻓﻲ ﻣﻠﻔﺎت اﻟﺒﺮﻣﺠﺔ ‪ ،BAS‬ﻓﺴـﺘﻈﻞ ﻣﺤﺘﻔﻈـﺔ ﺑﻘﻴﻤﺘﻬـﺎ ﺣﺘـﻰ ﻧﻬﺎﻳـﺔ ﺗﻨﻔﻴـﺬ‬
                                                                                ‫اﻟﺒﺮﻧﺎﻣﺞ.‬

                                                                          ‫اﻟﻤﺘﻐﻴﺮات‬
‫ﻧﺴﺘﻄﻴﻊ ان ﻧﻌﺮف اﻟﻤﺘﻐﻴﺮات ﺑﻤﻨﻈﻮرﻳﻦ، ﺑﺎﻟﻤﻨﻈﻮر اﻟﺮﻳﺎﺿـﻲ ﻳﻌـﺮف اﻟﻤﺘﻐﻴـﺮ ﻋﻠـﻰ اﻧـﻪ‬
‫ﻣﺠﻬﻮل س ﻳﺤﺘﻮي ﻋﻠﻰ ﻗﻴﻤﺔ ﻣﻌﻴﻨـﺔ، اﻣـﺎ ﺑـﺎﻟﻤﻨﻈﻮر اﻟﺒﺮﻣﺠـﻲ –وهـﻮ اﻻهـﻢ- ﻳﻌـﺮف‬
‫اﻟﻤﺘﻐﻴﺮ ﻋﻠﻰ اﻧﻪ ﻗﻴﻤﺔ ﺗﺤﻔﻆ ﻓﻲ ذاآﺮة اﻟﺠﻬﺎز. وﺗﺨﺘﻠﻒ اﻟﻤﺴـﺎﺣﺔ اﻟﻤﺤﺠـﻮزة ﻟﺤﻔـﻆ‬
‫هﺬﻩ اﻟﻘﻴﻤﺔ ﺑﺎﺧﺘﻼف ﻧـﻮع اﻟﻤﺘﻐﻴـﺮ، ﻓﻤﺘﻐﻴـﺮﻣﻦ اﻟﻨـﻮع ‪ Byte‬ﻻ ﻳﺴـﺘﻬﻠﻚ ﺳـﻮى ﺑﺎﻳـﺖ‬
‫واﺣﺪ ﻣﻦ ذاآﺮة اﻟﺤﺎﺳﺐ، ﻓﻲ ﺣﻴﻦ أن ﻣﺘﻐﻴﺮ ﻣﻦ ﻧﻮع ‪ String‬ﻗﺪ ﻳﺤﺠﺰ ﻣﺴﺎﺣﺔ ﺗﺼـﻞ‬
                                                               ‫اﻟﻰ 2 ﺟﻴﺠﺎﺑﺎﻳﺖ.‬
          ‫وﻓﻴﻤﺎ ﻳﻠﻲ ﻋﺮض ﻟﺠﻤﻴﻊ اﻧﻮاع اﻟﻤﺘﻐﻴﺮات اﻟﻤﺪﻋﻮﻣﺔ ﻣﻦ ﻗﺒﻞ ‪:Visual Basic‬‬

                                                      ‫اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪:Byte‬‬
‫ﻳﺴﺘﻄﻴﻊ هﺬا اﻟﻨﻮع اﻻﺣﺘﻔﺎظ ﺑﺎي ﻗﻴﻤﺔ ﺻﺤﻴﺤﺔ ﺿﻤﻦ اﻟﻤﺠﺎل اﻟﻌﺪدي ]0، 552[ وهﻮ‬
‫اﺻﻐﺮ اﻧﻮاع اﻟﻤﺘﻐﻴﺮات اذ ﻻ ﻳﺤﺘﺠﺰ ﺳﻮى 1 ﺑﺎﻳﺖ. ﺑﺪاﻳﺔ اﻟﻤﺘﻐﻴﺮات ﻣﻦ ﻧﻮع ‪ Byte‬آﺎﻧﺖ‬
‫ﻣﻨﺬ اﻻﺻﺪار 4‪ VB‬وآﺎﻧﺖ ﻣﻌﻈﻢ اﺳﺘﺨﺪاﻣﺎﺗﻬﺎ ﻓﻲ ﻧﺴﺨﺔ ‪ 16bit‬ﻣـﻦ اﻻﺻـﺪار 4‪ ،VB‬اذ‬
‫آﺎﻧﺖ اﻟﻤﺼﻔﻮﻓﺔ ﻣـﻦ اﻟﻨـﻮع ‪ Byte‬ﺗﺴـﺘﺨﺪم آﺜﻴـﺮا ﻋﻨـﺪ اﻻﺗﺼـﺎل ﺑـﺎﺟﺮاءات ‪ API‬اﻟﺘـﻲ‬
‫ﺗﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺤﺮوف، اﻣﺎ ﻣﻊ اﻻﺻﺪارات اﻻﺣﺪث ﻓﻠـﻦ ﺗـﺘﻤﻜﻦ ﻣـﻦ اﻻﺳـﺘﻔﺎدة وﺗﻄﺒﻴـﻖ‬
‫اﻟﻄــﺮق اﻟﻘﺪﻳﻤــﺔ ﻋﻠــﻰ اﻟﻤﺘﻐﻴــﺮات ﻣــﻦ اﻟﻨــﻮع ‪ ،Byte‬ﻻن اﻟﺘﺮﻣﻴــﺰ اﻟﻤﺘﺒــﻊ ‪UNICODE‬‬
‫ﻳﺴﺘﻬﻠﻚ ﻣﺴﺎﺣﺔ 2 ﺑﺎﻳﺖ ﻟﻠﺤﺮف اﻟﻮاﺣـﺪ وﻟـﻴﺲ 1 ﺑﺎﻳـﺖ آﺘﺮﻣﻴـﺰ ‪ .ASCII‬ﺑﺎﺧﺘﺼـﺎر، ﻻ‬
‫ﺗﻀﻊ ﻓﻲ ذهﻨﻚ أي ﻗﻀﺎﻳﺎ ﺣﺮﻓﻴﺔ ‪ Strings‬ﻋﻨﺪ اﺳﺘﺨﺪاﻣﻚ ﻟﻠﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨـﻮع ‪Byte‬‬
‫ﺧﺎﺻﺔ ﻋﻨـﺪ اﻟﻐـﻮص ﻓـﻲ اﻋﻤـﺎق اﺟـﺮاءات ‪ ،API‬ﻓـﻴﻤﻜﻦ ﻗﺼـﺮ اﺳـﺘﺨﺪاﻣﻚ ﻟﻬـﺎ ﻋﻠـﻰ‬
                    ‫اﻻﻋﺪاد اﻟﺼﻐﻴﺮة او اﻟﺒﻴﺎﻧﺎت اﻟﺜﻨﺎﺋﻴﺔ ﻣﻊ اﻟﻤﺘﻐﻴﺮات ﻣﻦ ﻧﻮع ‪.Byte‬‬

                                                       ‫اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪:Integer‬‬
                                                ‫67‬


‫اﺳﻨﺪ أي ﻗﻴﻤﺔ ﻋﺪدﻳﺔ ﺻﺤﻴﺤﺔ ﻓﻲ اﻟﻤﺠﺎل ]-867,23، 767,23[ ﻟﻠﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع‬
‫‪ Integer‬ﻓﻬــﻲ ﺗﺤﺠــﺰ ﻣﺴــﺎﺣﺔ 2 ﺑﺎﻳــﺖ. وﻋﻨــﺪ اﻟﺤــﺪﻳﺚ ﻋــﻦ اﺟــﺮاءات ‪ API‬اﻟﺨﺎﺻــﺔ‬
‫ﺑﺎﻟﺤﺮوف، ﻓﺎﻟﻤﺼﻔﻮﻓﺔ ﻣﻦ اﻟﻨﻮع ‪ Integer‬هﻲ اﻻﻧﺴﺐ ﻟﻠﺘﺮﻣﻴﺰ ‪ .UNICODE‬ﺑﻌﻴﺪا ﻋـﻦ‬
‫اﺟﺮاءات ‪ API‬اﻟﺤﺮﻓﻴـﺔ، ﺗﻔﻴـﺪك اﻟﻤﺘﻐﻴـﺮات ﻣـﻦ هـﺬا اﻟﻨـﻮع ﻋﻨـﺪ اﻟﺘﻌﺎﻣـﻞ ﻣـﻊ اﻻﻋـﺪاد‬
‫اﻟﺼﺤﻴﺤﺔ، اﻻ اﻧﻨﻲ اﺣﺒﺬ اﺳﺘﺨﺪام اﻟﻤﺘﻐﻴﺮات ﻣـﻦ اﻟﻨـﻮع ‪ Long‬ﻟﻘـﺪرﺗﻬﺎ ﻋﻠـﻰ اﺣﺘـﻮاء‬
‫ﻗﻴﻢ اآﺒﺮ ﺑﻜﺜﻴﺮ ﻣﻦ اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨـﻮع ‪ ،Integer‬آﻤـﺎ اﻧﻬـﺎ اﻟﻨـﻮع اﻟﻘﻴﺎﺳـﻲ ﻻﻏﻠـﺐ‬
‫اﺟﺮاءات ‪ .API‬اﻣﺎ ﻓﻲ ﺣﺎﻟﺔ اﻟﻤﺼـﻔﻮﻓﺎت اﻟﻜﺒﻴـﺮة، ﻓـﺎﻧﻨﻲ اﻓﻀـﻞ اﺳـﺘﺨﺪام اﻟﻤﺘﻐﻴـﺮات‬
                                ‫ﻣﻦ اﻟﻨﻮع ‪ Integer‬ﻟﺘﻮﻓﻴﺮ 05% ﻣﻦ ﻣﺴﺎﺣﺔ اﻟﺬاآﺮة.‬

                                                    ‫اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪:Long‬‬
‫اﻟﻤﺘﻐﻴــﺮات ﻣــﻦ ﻧــﻮع ‪ Long‬ﺗﺴــﺘﻄﻴﻊ ﺣﻤــﻞ ﻗــﻴﻢ ﻋﺪدﻳــﺔ ﺻــﺤﻴﺤﺔ ﻓــﻲ اﻟﻤﺠــﺎل ]-‬
‫846,384,741,2، 746,384,741,2[ ﻓﻬــﻲ ﺗﺤﺠــﺰ ﻣﺴــﺎﺣﺔ ﻗــﺪرهﺎ 4 ﺑﺎﻳــﺖ ﻟﻠﻤﺘﻐﻴــﺮ‬
‫اﻟﻮاﺣﺪ، وآﻤﺎ ذآﺮت ﻓﻲ اﻟﻔﻘﺮة اﻟﺴﺎﺑﻘﺔ اﻧﻲ اﺣﺒﺬ اﺳﺘﺨﺪاﻣﻬﺎ ﻋﻮﺿـﺎ ﻋـﻦ اﻟﻤﺘﻐﻴـﺮات‬
‫ﻣﻦ اﻟﻨﻮع ‪ ،Integer‬ﻓﻬﻲ ﺗﺤﻤﻞ ﻗﻴﻢ آﺒﻴﺮة ﺟﺪا ﻣﻘﻠﻠﺔ اﻟﺨـﻮف ﻣـﻦ ﻇﻬـﻮر ﺧﻄـﺄ وﻗـﺖ‬
‫اﻟﺘﻨﻔﻴﺬ ‪ ،Overflow‬ﻓﻠﻮ آﺘﺒﺖ آﻮد ﻳﻘﺮأ ﺣﺠﻢ ﻣﻠﻒ ﻣﻌﻴﻦ وآﻨـﺖ ﻣـﻦ اﻟﻤـﺪﻣﻨﻴﻦ ﻟﻠﻨـﻮع‬
‫‪ ،Integer‬ﻓﺴﺘﺼﺎب ﺑﺨﻴﺒﺔ اﻣﻞ آﺒﻴﺮة ﻋﻨﺪﻣﺎ ﺗﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﻠﻔﺎت اﻟﺘﻲ ﺗﺰﻳـﺪ اﺣﺠﺎﻣﻬـﺎ‬
                                                                    ‫ﻋﻦ 767,23:‬

‫‪Dim iFileSize As Integer‬‬

‫ﺳﻴﻈﻬﺮ ﺧﻄﺄ اذا زاد ﺣﺠﻢ اﻟﻤﻠﻒ ﻋﻦ 676,23 ﺑﺎﻳﺖ ‘‬
‫)”‪iFileSize = FileLen (“C:\MyFile.DAT‬‬

                                                     ‫اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪:Boolean‬‬
‫اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪ Boolean‬هﻲ ﻧﻔﺲ اﻟﻤﺘﻐﻴﺮات ﻣـﻦ اﻟﻨـﻮع ‪ Integer‬وﻟﻜـﻦ اﻟﻘـﻴﻢ‬
‫اﻟﺘﻲ ﺗﻤﻜﻨﻚ ﻣﻦ اﺳﻨﺎدهﺎ اﻟﻴﻬﺎ ﺗﻜﻮن اﻣـﺎ 0 ‪ False‬او -1 ‪ ،True‬ﺣﺠـﻢ اﻟﻤﺘﻐﻴـﺮات ﻣـﻦ‬
‫اﻟﻨــﻮع ‪ Boolean‬ﻣﺜــﻞ ﺣﺠــﻢ اﻟﻤﺘﻐﻴــﺮات ﻣــﻦ اﻟﻨــﻮاع ‪ Integer‬أي 2 ﺑﺎﻳــﺖ، اﻻ اﻧﻬــﺎ ﻻ‬
‫ﺗﺴﺘﺨﺪم ﺳﻮى 1 ﺑﺖ ﻣﺘﺠﺎهﻠﺔ اﻟـ 51 ﺑﺖ اﻻﺧﺮى. ﺻـﺤﻴﺢ ان اﻟﺤﺠـﻢ 2 ﺑﺎﻳـﺖ ﻳﻌﺘﺒـﺮ‬
‫زﻳﺎدة ﻏﻴﺮ ﻣﺴﺘﺨﺪﻣﺔ، اﻻ ان اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪ Boolean‬ﺗﺴﻬﻞ ﻋﻠﻴﻚ ﻋﻤﻠﻴﺔ ﻗﺮاءة‬
                                                                         ‫وﻓﻬﻢ اﻻآﻮاد.‬
                                            ‫77‬


                                                  ‫اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪:Single‬‬
‫ﻣﺠﺎل اﻟﻘﻴﻢ اﻟﺘﻲ ﻳﻤﻜﻦ ﻟﻠﻤﺘﻐﻴﺮات ﻣـﻦ اﻟﻨـﻮع ‪ Single‬اﺣﺘﻮاﺋﻬـﺎ هـﻮ اﻻﻋـﺪاد اﻟﻤﻮﺟﺒـﺔ‬
‫ﻣﻦ 54-‪ 1.401298e‬اﻟﻰ 83‪ 3.402823e‬او اﻻﻋﺪاد اﻟﺴﺎﻟﺒﺔ ﻣﻦ 83‪ -3.402823e‬اﻟﻰ‬
                                       ‫54-‪ -1.401298e‬وﺗﺴﺘﻬﻠﻚ ﻣﺴﺎﺣﺔ 4 ﺑﺎﻳﺖ.‬
‫رﺑﻤــﺎ ﻳﻔﻀــﻞ ﻣﻌﻈــﻢ ﻣﺒﺮﻣﺠــﻲ ‪ Visual Basic‬اﻟﻨــﻮع ‪ Single‬ﻋﻠــﻰ اﻟﻨــﻮع ‪Double‬‬
‫ﻻﻋﺘﻘﺎدهﻢ ان اﻷول اﺳﺮع ﻓﻲ اﻟﺘﻨﻔﻴﺬ ﻣﻦ اﻟﺜـﺎﻧﻲ، هـﺬا اﻻﻋﺘﻘـﺎد ﺻـﺤﻴﺢ ﻓـﻲ اﻟﻨـﻮع‬
‫اﻟﻘﺪﻳﻢ ﻣﻦ اﻟﻤﻌﺎﻟﺠﺎت واﻟﺘﻲ ﻻ ﺗﺤﺘﻮي ﻋﻠـﻰ ﻣﺴـﺎﻋﺪ رﻳﺎﺿـﻲ ‪،Math Coprocessor‬‬
‫اﻣﺎ اﻏﻠﺐ اﻟﻤﻌﺎﻟﺠﺎت اﻟﺠﺪﻳﺪ ﺗﺤﺘﻮي ﻋﻠﻰ اﻟﻤﺴﺎﻋﺪ اﻟﺮﻳﺎﺿـﻲ وهـﻮ ﺧـﺎص ﺑﺎﻟﻌﻤﻠﻴـﺎت‬
‫اﻟﺤﺴﺎﺑﻴﺔ ﻟﻼﻋﺪاد ذات اﻟﻔﺎﺻﻠﺔ اﻟﻌﺎﺋﻤﺔ ‪ Floating Point‬ﻣﻤﺎ ﻳﺠﻌﻞ اﻟﺴـﺮﻋﺔ ﻣﺘﻘﺎرﺑـﺔ‬
‫ﺟﺪا ﺑﻴﻦ اﻟﻨﻮﻋﻴﻦ ‪ Single‬و ‪ ،Double‬ﻟﺬﻟﻚ ﻳﻨﺼﺢ ﺑﺎﺳﺘﺨﺪام اﻟﻨﻮع ‪ Double‬ﻋﻮﺿﺎ ﻋـﻦ‬
‫اﻟﻨﻮع ‪ Single‬ﺣﺘﻰ ﺗﺘﻘﻲ ﺷﺮ اﻟﺨﻄﺄ ‪ OverFlow‬ودﻗﺔ اﻋﻠﻰ ﻟﻼﻋﺪاد ﻟﻜﺒﺮ ﻣﺠﺎل اﻟﻘﻴﻢ‬
‫اﻟﻤﻤﻜﻨﺔ ﺑﻬﺎ. ﻣﻦ ﻧﺎﺣﻴﺔ اﺧﺮى، ﻗﺪ ﺗﻜﻮن اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪ Single‬اﺳﺮع ﺑﻜﺜﻴﺮ ﻣـﻦ‬
‫اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪ Double‬ﻋﻨﺪ اﻟﺘﻌﺎﻣﻞ ﻣـﻊ اﻟﺨﺼـﺎﺋﺺ او اﻟﻄـﺮق اﻟﺘـﻲ ﺗﺤﺘـﻚ ﻣـﻊ‬
‫اﻻﺣﺪاﺛﻴﺎت ﺑﺸـﻜﻞ ﻣﻠﺤـﻮظ آــ ‪CurrentX ،Circle ،Line ،ScaleWidth ،ScaleHeight‬‬
‫.... اﻟﺦ ﻓﻬﺬﻩ اﻻﺣﺪاﺛﻴﺎت ﺗﺴﺘﺨﺪم اﻟﻨﻮع ‪ ،Single‬واﺳﺘﺨﺪام اﻟﻨﻮع ‪ Double‬ﻣﻌﻬﺎ اﺑﻄـﺄ‬
            ‫ﻻن ‪ Visual Basic‬ﻳﻀﻄﺮ اﻟﻰ ﺗﺤﻮﻳﻞ ﻣﺘﻐﻴﺮات اﻟﻨﻮع اﻟﺴﺎﺑﻖ اﻟﻰ ‪.Single‬‬

                                                ‫اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪:Double‬‬
‫ﻣﺠﺎل اﻟﻘﻴﻢ اﻟﺘﻲ ﻳﻤﻜﻦ ﻟﻠﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪ Double‬اﺣﺘﻮاﺋﻬـﺎ هـﻮ اﻻﻋـﺪاد اﻟﻤﻮﺟﺒـﺔ‬
‫ﻣﻦ 423-‪ 4.9406564581247e‬اﻟﻰ 803‪ 1.79769313486232e‬او اﻻﻋـﺪاد اﻟﺴـﺎﻟﺒﺔ‬
‫ﻣــــﻦ 423-‪ -4.9406564581247e‬اﻟــــﻰ 803‪ -1.79769313486232e‬وﺗﺴــــﺘﻬﻠﻚ‬
                                                               ‫ﻣﺴﺎﺣﺔ 8 ﺑﺎﻳﺖ.‬
‫ﻣﻌﻈﻢ دوال ‪ Visual Basic‬اﻟﺨﺎﺻﺔ ﺑﺎﻻﻋﺪاد ﺗﻌﻮد ﺑﻘﻴﻤﺔ ﻣـﻦ اﻟﻨـﻮع ‪ Double‬ﻟـﺬﻟﻚ هـﻮ‬
‫اﻟﻨﻮع اﻟﻤﻔﻀﻞ داﺋﻤﺎ، اﻻ ان ﻋﻴﺒﻪ اﻟﻮﺣﻴﺪ هﻮ ﻓﻲ اﻟﻤﺴﺎﺣﺔ اﻟﻜﺒﻴﺮ اﻟﺘﻲ ﻳﺤﺘﺠﺰهﺎ، وﻗﺪ‬
                    ‫ﻳﻈﻬﺮ هﺬا اﻟﻌﻴﺐ ﺟﻠﻴﺎ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺎت اﻟﻜﺒﻴﺮة ﻣﻦ اﻟﻨﻮع ‪.Double‬‬

                                              ‫اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪:Currency‬‬
‫ﻳﻤﻜﻦ ﻟﻠﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪ Currency‬اﻻﺣﺘﻔﺎظ ﺑﻘﻴﻢ ﻋﺸﺮﻳﺔ ﻟﻠﻔﺎﺻﻠﺔ اﻟﺜﺎﺑﺘـﺔ -‪Fixed‬‬
‫‪ Point‬ﺷﺮﻳﻄﺔ ان ﺗﻜﻮن ﻣﺤﺼﻮرة ﻓﻲ داﺧﻞ اﻟﻤﺠﺎل ]-8085.774,586,302,733,229،‬
‫8085.774,586,302,733,229[ وﺣﺠﻤﻬﺎ 8 ﺑﺎﻳﺖ اﻳﻀﺎ. ﻳﻮﻓﺮ هﺬا اﻟﻨﻮع ﻣﻦ اﻟﻤﺘﻐﻴـﺮات‬
‫ﻋﻨﺎء اﻟﺘﻘﺮﻳـﺐ ﺑﺎﺳـﺘﺨﺪام دوال اﻟﺘﻘﺮﻳـﺐ آــ ‪ .... Round ،Fix‬اﻟـﺦ واﻟﺘـﻲ ﺗﺴـﺘﺨﺪﻣﻬﺎ‬
‫ﺑﻜﺜﺮة ﻣﻊ اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪ Double‬و ‪ Single‬ﻣﻤﺎ ﻳﺒﻄﺊ اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴـﺎﺑﻴﺔ، ﻣـﻊ‬
‫ذﻟﻚ اﻻﺳﺘﺨﺪام اﻟﻤﺠﺮد ﻟﻠﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪ Currency‬اﺑﻄﺄ ﺧﻤﺲ او ارﺑﻊ ﻣﺮات ﻣـﻦ‬
                                             ‫87‬


‫اﻟﻤﺘﻐﻴﺮات ‪ Double‬و ‪ Single‬ﻓﻼ ﺗﺴﺘﺨﺪﻣﻬﺎ ﺑﻜﺜﺮة ﻓـﻲ ﺣﺎﻟـﺔ ﺗﻄﺒﻴـﻖ ﺁﻻف اﻟﻌﻤﻠﻴـﺎت‬
                                                           ‫اﻟﺤﺴﺎﺑﻴﺔ ﻋﻠﻴﻬﺎ.‬

                                             ‫اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪:Decimal‬‬
‫اﻻﻋﺪاد اﻟﺘﻲ ﻳﻤﻜﻨﻚ اﺳﻨﺎدهﺎ اﻟﻰ اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪ Decimal‬آﺒﻴﺮة ﺟﺪا، وﻻ ﻳﻮﺟﺪ‬
‫داﻋﻲ ﻟـﺬآﺮهﺎ هﻨـﺎ ﻣﺎداﻣـﺖ ﻣﻜﺘﺒـﺔ ‪ MSDN‬ﻋﻠـﻰ ﻗﻴـﺪ اﻟﺤﻴـﺎة. ﻟـﻦ ﺗﺴـﺘﻄﻴﻊ ﺗﺼـﺮﻳﺢ‬
‫اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪ Decimal‬ﻣﺒﺎﺷﺮة ﺑﺎﻟﻄﺮﻳﻘﺔ اﻟﺘﻘﻠﻴﺪﻳﺔ ‪ ،Dim X As Decimal‬واﻧﻤﺎ‬
          ‫ﺗﺴﺘﺨﺪم اﻟﻨﻮع ‪- Variant‬اﻟﺬي ﻳﺴﺘﻬﻠﻚ 61 ﺑﺎﻳﺖ- وﻣﻦ ﺛﻢ ﺗﺴﻨﺪ ﻗﻴﻤﺔ ﻟﻪ:‬

‫‪Dim X As Variant‬‬
‫)‪X = CDec (Text1.Text) * CDec (Text2.Text‬‬

‫وﻻ ﺗﻨﺴﻰ ان اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪ Variant‬هﻲ اﺑﻄﺄ اﻧﻮاع اﻟﻤﺘﻐﻴﺮات آﻤﺎ ﺳﺘﻘﺮأ ﻓﻲ‬
                                      ‫ﻓﻘﺮة "اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪ "Varaint‬ﻗﺮﻳﺒﺎ.‬

                                                      ‫اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪:Date‬‬
‫هﺬا اﻟﻨﻮع ﻣﻦ اﻟﻤﺘﻐﻴﺮات ﻳﺤﻤﻞ ﻗـﻴﻢ ﺗﺎرﻳﺨﻴـﺔ ﺗﺒـﺪأ ﻣـﻦ اﻟﺘـﺎرﻳﺦ 1 ﻳﻨـﺎﻳﺮ 001 اﻟـﻰ 13‬
‫دﻳﺴﻤﺒﺮ 9999 وﻳﺸﻤﻞ ﻧﻔﺲ اﻟﻤﺘﻐﻴـﺮ وﻗـﺖ ﻳﺒـﺪأ ﻣـﻦ اﻟﺴـﺎﻋﺔ 00:00:00 ص ﺣﺘـﻰ‬
‫اﻟﺴﺎﻋﺔ 95:95:32 م وﺗﺴﺘﻬﻠﻚ ﻣﺴﺎﺣﺔ 8 ﺑﺎﻳﺖ، وﻓﻲ ﺣﻘﻴﻘـﺔ اﻻﻣـﺮ اﻟﻤﺘﻐﻴـﺮات ﻣـﻦ‬
‫اﻟﻨﻮع ‪ Date‬هﻲ ﻧﻔﺲ اﻟﻤﺘﻐﻴـﺮات ﻣـﻦ اﻟﻨـﻮع ‪ ،Double‬ﻓـﺎﻟﺠﺰء اﻟﻌﺸـﺮي ﻳﻤﺜـﻞ وﻗـﺖ‬
‫ﻣﻌﻴﻦ واﻟﺠﺰء اﻟﺼﺤﻴﺢ ﻳﻤﺜـﻞ ﺗـﺎرﻳﺦ ﻣﻌـﻴﻦ، ﻓﺎﻟﻘﻴﻤـﺔ 5.75273 ﺗﻤﺜـﻞ اﻟﺴـﺎﻋﺔ اﻟﺜﺎﻧﻴـﺔ‬
‫ﻋﺸﺮ ﻇﻬﺮا ﻣﻦ ﻳﻮم 1 ﻳﻨﺎﻳﺮ ﻋﺎم 2002. اﻟﺴﺒﺐ اﻟﺬي ﺟﻌﻠﻨﻲ اذآﺮ ﺗﻔﺎﺻﻴﻞ اﻟﻤﺘﻐﻴـﺮات‬
‫ﻣﻦ هﺬا اﻟﻨﻮع هﻮ اﻋﻄﺎﺋﻚ اﻓﻜـﺎر ﻣﺮﻧـﺔ ﺗﻤﻜﻨـﻚ ﻣـﻦ اﺟـﺮاء ﻋﻤﻠﻴـﺎت آﺜﻴـﺮة ﻋﻠـﻰ ﻗـﻴﻢ‬
                                             ‫اﻟﺘﺎرﻳﺦ وهﺬﻩ ﻗﻄﺮات ﻣﻦ ﻣﺤﻴﻂ اﻻﻣﺜﻠﺔ:‬

‫‪Dim dDateVar As Date‬‬

‫‪dDateVar = Now‬‬
‫اﻃﺒﻊ اﻟﺘﺎرﻳﺦ ﻓﻘﻂ ‘‬
‫)‪Print Int(dDateVar‬‬
‫اﻃﺒﻊ اﻟﻮﻗﺖ ﻓﻘﻂ ‘‬
‫))‪Print CDate(dDateVar - Int(dDateVar‬‬
‫اﺿﻒ اﺳﺒﻮع واﺣﺪ ‘‬
‫7 + ‪Print dDateVar‬‬
‫اﺣﺬف 03 ﻳﻮم ‘‬
                                                 ‫97‬


‫03 - ‪Print dDateVar‬‬
‫اﺣﺬف 6 ﺳﺎﻋﺎت ‘‬
‫57.0 - ‪Print dDateVar‬‬

 ‫ان ﻟﻢ ﺗﻜﻦ دﻗﻴﻖ ﻓﻲ آﺘﺎﺑﺔ اﻻﻋـﺪاد اﻟﻤﻨﺎﺳـﺒﺔ –وﺧﺼﻮﺻـﺎ اﻟﻌﺸـﺮﻳﺔ،‬               ‫ﻣﻼﺣﻈﺔ:‬
 ‫ﻓﺎن ﻧﺘﺎﺋﺞ اﻟﻌﻤﻠﻴﺎت اﻟﺴﺎﺑﻘﺔ ﻟﻦ ﺗﻜﻮن ﻣﺘﻮﻗﻌﺔ، ﻟﺬﻟﻚ ﻳﻨﺼﺢ ﺑﺎﺳﺘﺨﺪام‬
 ‫دوال اﻟﻮﻗﺖ واﻟﺘﺎرﻳﺦ اﻟﻤﻀﻤﻨﺔ ﻓﻲ ﻣﻜﺘﺒﺎت ‪ VB‬و ‪ VBA‬آﻤﺎ ﺳﻴﻔﺼـﻠﻬﺎ‬
                                              ‫ﻟﻚ اﻟﻔﺼﻞ اﻟﻘﺎدم.‬

                                                        ‫اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪:String‬‬
‫ﻟﻤﺎذا ﻟﻐﺔ اﻟـ ‪ BASIC‬ﺳﻬﻠﺔ؟ واﻟﺠﻮاب ﺑﺴﺒﺐ اﻟﻤﺘﻐﻴﺮات اﻟﺤﺮﻓﻴﺔ ﻣـﻦ ﻧـﻮع ‪ !String‬اذا‬
‫آﻨﺖ ﻣﻦ ﻣﺒﺮﻣﺠﻲ ‪ C‬ﻓﺎﻧﺴﻰ آﻞ ﺷﺊ ﻣﺘﻌﻠﻖ ﺑﻘﻀـﻴﺔ ﺣﺠـﺰ اﻟﻤﺴـﺎﺣﺔ ﻓـﻲ اﻟـﺬاآﺮة‬
‫ﺳﻮاء آﺎن دﻳﻨﺎﻣﻴﻜﻴﺎ او ﺳﺘﺎﺗﻴﻜﻴﺎ ﺑﺎﺳﺘﺨﺪام اﻟﻤﺼﻔﻮﻓﺎت، او اﻟﺘﺤﻘـﻖ ﻣـﻦ ﻃـﻮل اﻟـﻨﺺ‬
‫وﻏﻴﺮهﺎ ﻣﻦ اﻻﻣﻮر اﻟﺘﻲ ﺗﺘﻄﻠﺐ 3 او 6 ﺳـﻄﻮر ﻻﺳـﻨﺎد ﻗﻴﻤـﺔ اﻟـﻰ ﻣﺘﻐﻴـﺮ ﺣﺮﻓـﻲ، ﻓــ‬
‫‪ Visual Basic‬هﻮ اﻟﻤﺘﻜﻔﻞ ﺑﻬﺬﻩ اﻻﻣﻮر ﺗﻠﻘﺎﺋﻴﺎ ﺑﻤﺠﺮد ﺗﺼﺮﻳﺢ ﻣﺘﻐﻴـﺮ ﻣـﻦ اﻟﻨـﻮع ‪String‬‬
                                                                ‫او اﺳﻨﺎد ﻗﻴﻢ ﺣﺮﻓﻴﺔ ﻟﻪ.‬
‫ﻣﻨﺬ اﻻﺻﺪار 4‪– VB‬ﻧﺴﺨﺔ ﻋﻴﺎر 23ﺑـﺖ- اﺻـﺒﺤﺖ اﻟﻤﺘﻐﻴـﺮات اﻟﺤﺮﻓﻴـﺔ ‪ Strings‬ﺗﻌﺘﻤـﺪ‬
‫ﺗﺮﻣﻴــﺰ ‪ UNICODE‬وﻟــﻴﺲ ‪ .ASCII‬ﺑﺼــﻔﺔ ﻋﺎﻣــﺔ، ﻳﻮﺟــﺪ ﻧﻮﻋــﺎن ﻣــﻦ اﻧــﻮاع اﻟﻤﺘﻐﻴــﺮات‬
‫اﻟﺤﺮﻓﻴــﺔ ﻳﻮﻓﺮهﻤــﺎ ‪ Visual Basic‬ﻟــﻚ هﻤــﺎ اﻟﻤﺘﻐﻴــﺮات ﺛﺎﺑﺘــﺔ اﻟﻄــﻮل ‪Fixed-length‬‬
                                                     ‫واﻟﻤﺘﻐﻴﺮة اﻟﻄﻮل ‪.Variable-Length‬‬
‫اﻟﻤﺘﻐﻴﺮات ﺛﺎﺑﺘﺔ اﻟﻄﻮل هﻲ ﻣﺘﻐﻴﺮات ﺣﺮﻓﻴﺔ ﻋﺪد ﺣﺮوﻓﻬﺎ ﻣﺤﺪد ﻓﻲ اﺛﻨﺎء ﺗﺼـﺮﻳﺤﻬﺎ وﻻ‬
                                                                        ‫ﻳﻤﻜﻦ ان ﻳﺘﻐﻴﺮ:‬

‫21 * ‪Dim FixedStr As String‬‬

‫”ﺗﺮآﻲ اﻟﻌﺴﻴﺮي“ = ‪sFixedStr‬‬

‫ﻓﺎﻟﻌﺪد اﻻﻗﺼﻰ ﻣـﻦ اﻟﺤـﺮوف اﻟﺘـﻲ ﻳﻤﻜـﻦ ﻟﻠﻤﺘﻐﻴـﺮ ‪ FixedStr‬ان ﻳﺤﻤﻠـﻪ هـﻮ 21 ﻣﻤـﺎ‬
‫ﻳﺆدي اﻟﻰ اﺳﺘﻬﻼك ﻣﺴﺎﺣﺔ ﻗﺪرهﺎ 42 ﺑﺎﻳـﺖ –ﻻ ﺗﻨﺴـﻰ ان ‪ UNICODE‬ﻳﺴـﺘﻬﻠﻚ 2‬
‫ﺑﺎﻳﺖ ﻟﻠﺤﺮف اﻟﻮاﺣﺪ. ﻣﻦ ﻋﻴﻮب اﻟﻤﺘﻐﻴـﺮات ﺛﺎﺑﺘـﺔ اﻟﻄـﻮل هـﻮ ﻋـﺪم ﺗﻮاﻓﻘﻬـﺎ ﻣـﻊ ﺗﻘﻴﻨـﺔ‬
‫‪ COM‬وﻣﻌﻈﻢ دوال ﻣﻜﺘﺒﺎت ‪ VB‬و ‪ VBA‬اﻟﺪاﺧﻠﻴﺔ واﺟﺮاءات ‪ API‬ﻻ ﺗﺪﻋﻢ هﺬا اﻟﻨﻮع ﻣﻦ‬
    ‫ـ‬       ‫ـ‬    ‫ـ‬   ‫ـ‬       ‫ـ‬
‫اﻟﻤﺘﻐﻴ ـﺮات، وﺣﺘ ـﻰ ﻟ ـﻮ آ ـﺎن ﻋ ـﺪد ﺣ ـﺮوف اﻟﻘﻴﻤ ـﺔ اﻟﻤﺴ ـﻨﺪة اﻗ ـﻞ ﻣ ـﻦ ﻋ ـﺪد اﻟﺤ ـﺮوف‬
                                     ‫ـ‬          ‫ـ‬     ‫ـ‬     ‫ـ ـ‬       ‫ـ‬         ‫ـ‬
‫اﻟﻤﺼﺮﺣﺔ، ﻓﺎن اﻟﻤﺴﺎﻓﺎت " " ﺳﺘﺤﻞ ﻣﺤﻞ اﻟﺨﺎﻧﺎت اﻟﻔﺎرﻏﺔ، وﻻ ﻳﻤﻜﻦ ﻟﻬﺬا اﻟﻨﻮع ﻣﻦ‬
‫اﻟﻤﺘﻐﻴﺮات ان ﺗﻜﻮن ﻣﺮﺋﻴـﺔ ﻋﻠـﻰ ﻣﺴـﺘﻮى اﻟﻮﺣـﺪة ﻣـﻦ اﻟﻨـﻮع ‪ ،Public‬آﻤـﺎ ﻻ ﻳﻤﻜﻨـﻪ‬
‫ﺣﻤﻞ ﻋﺪد ﻣﻦ اﻟﺤﺮوف اآﺒﺮ ﻣﻦ 46 آﻴﻠﻮﺑﺎﻳﺖ، اﻻ ان اﻟﻤﻴﺰة اﻟﺘﻲ ﺗﻈﻬﺮ ﺑﻬﺎ ﻋﻨﺪ اﺳﻨﺎد‬
                                             ‫08‬


‫اﻟﻘﻴﻢ اﻟﺤﺮﻓﻴﺔ ﻟﻬﺬا اﻟﻤﺘﻐﻴﺮات ﻓﻨﺘﺎﺋﺠﻬﺎ ﺗﻜﻮن داﺋﻤـﺎ اﺳـﺮع ﻣـﻦ اﻟﻤﺘﻐﻴـﺮات ﻣـﻦ اﻟﻨـﻮع‬
‫اﻟﻤﺘﻐﻴﺮة اﻟﻄﻮل، وذﻟﻚ ﻻن ‪ Visual Basic‬ﻻ ﻳﻘـﻮم ﺑـﺎي ﻋﻤﻠﻴـﺎت اﺣﺘﺠـﺎز ﻓـﻲ اﻟـﺬاآﺮة‬
                                          ‫واﻟﺘﺤﻘﻖ ﻣﻦ اﻟﻤﺴﺎﺣﺔ اﻟﻤﺘﻮﻓﺮة .... اﻟﺦ.‬

 ‫‪ COM‬او ﺑﺮﻣﺠـﺔ اﻟﻜﺎﺋﻨـﺎت اﻟﻤﻜﻮﻧـﺔ ‪ Component Object Model‬ﻣـﻦ‬          ‫ﻣﻼﺣﻈﺔ:‬
 ‫اﻟﺘﻘﻨﻴﺎت اﻟﻤﺒﻨﻴـﺔ ﻋﻠـﻰ ‪ OLE‬واﻟﺘـﻲ ﺗﻤﻜـﻦ ﺗﻄﺒﻴﻘـﺎت ‪ Windows‬ﻣـﻦ‬
 ‫اﻻﺗﺼﺎل وﺗﺒﺎدل اﻟﺒﻴﺎﻧﺎت ﻓﻴﻤـﺎ ﺑﻴﻨﻬـﺎ، اﻟﻔﺼـﻼن اﻟﺜـﺎﻧﻲ ﻋﺸـﺮ واﻟﺜﺎﻟـﺚ‬
               ‫ﻋﺸﺮ "ﺑﺮﻣﺠﺔ اﻟﻤﻜﻮﻧﺎت ‪ "COM‬ﻳﺨﺘﺼﺎن ﺑﻬﺬﻩ اﻟﺘﻘﻨﻴﺔ.‬

‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﺘﻐﻴﺮات اﻟﻤﺘﻐﻴـﺮة اﻟﻄـﻮل ‪ Variable-Length‬ﻓﻬـﻲ ﺑﺎﺧﺘﺼـﺎر ﺗﻐﻄـﻲ ﻋﻠـﻰ‬
‫ﺟﻤﻴﻊ ﻋﻴﻮب اﻟﻨﻮع اﻟﺴﺎﺑﻖ، اﻻ اﻧﻬﺎ ﺗﺤﺘﺠﺰ ﻣﺴﺎﺣﺔ ﺗﻌﺎدل ﺿـﻌﻒ ﻋـﺪد اﻟﺤـﺮوف + 01‬
‫ﺑﺎﻳﺘﺎت اﺿﺎﻓﻴﺔ ﺗﺤﻮي ﻣﻌﻠﻮﻣﺎت ﻋﻦ اﻟﻤﺘﻐﻴـﺮ اﻟﺤﺮﻓـﻲ آﺤﺠﻤـﻪ وﻏﻴﺮهـﺎ ﻣـﻦ اﻟﺘﻔﺎﺻـﻴﻞ‬
‫اﻟﺘﻲ ﻳﺨﻔﻴﻬﺎ ‪ Visual Basic‬ﻋﻨﻚ، واﻟﻌﺪد اﻻﻗﺼـﻰ ﻣـﻦ اﻟﺤـﺮوف اﻟﺘـﻲ ﻳﻤﻜـﻦ ﺣﻔﻈﻬـﺎ‬
                                         ‫ﻓﻲ هﺬا اﻟﻨﻮع ﻳﺼﻞ إﻟﻰ 2 ﺟﻴﺠﺎ ﺑﺎﻳﺖ.‬

                                             ‫اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪:Object‬‬
‫ﻣﻌﻈﻢ اﻟﻤﺘﻐﻴﺮات اﻟﺘﻲ ﺗﻤﺜﻞ آﺎﺋﻨﺎت ﺳﻮاء ﺻﺮﺣﺖ ﺑﺎﻟﻨﻮع ‪ Object‬او ﺑﻨـﻮع ﻓﺌـﺎت هـﻲ‬
                                                   ‫ﻣﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪:Object‬‬

‫‪Dim X As Object‬‬
‫‪Dim Y As Form‬‬
‫‪Dim Z As Text‬‬

‫اود ان اؤﺟﻞ ﺷﺮح ﺗﻔﺎﺻﻴﻞ اﻟﻜﺎﺋﻨﺎت –اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪ -Object‬ﺣﺘﻰ اﻟﻮﺻﻮل اﻟﻰ‬
‫اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ "اﻟﺒﺮﻣﺠﺔ آﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ" وﺣﺘﻰ ذﻟﻚ اﻟﺤﻴﻦ، ﻻ ﺗﺴﻨﺪ آﺎﺋﻦ اﻟﻰ آﺎﺋﻦ‬
                                                    ‫اﻻ ﺑﺎﺳﺘﺨﺪام اﻟﻌﺒﺎرة ‪:Set‬‬

‫‪Set X = New MyClass‬‬
‫1‪Set Y = Form‬‬
‫1‪Set Z = Text‬‬
‫”اﺳﻨﺎد ﻗﻴﻤﺔ ﺧﺎﺻﻴﺔ وﻟﻴﺲ آﺎﺋﻦ“ = ‪Z‬‬
‫”اﺳﻨﺎد ﻗﻴﻤﺔ ﺧﺎﺻﻴﺔ وﻟﻴﺲ آﺎﺋﻦ“ = ‪Z.Text‬‬

                   ‫ﻻ ﺗﺸﻐﻞ ﺑﺎﻟﻚ آﺜﻴﺮا ﺑﺎﻟﻜﻮد اﻟﺴﺎﺑﻖ، ﻓﺎﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ ﻗﺎدم اﻟﻴﻚ.‬
                                                  ‫18‬


                                                   ‫اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪:Variant‬‬
‫ﻇﻬﺮت اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨـﻮع ‪ Variant‬ﻓـﻲ اﻻﺻـﺪار 3‪ VB‬وﺗﻌـﺪﻟﺖ ﺑﻨﻴﺘـﻪ اﻟﺘﺤﺘﻴـﺔ ﻣﻨـﺬ‬
‫اﻻﺻﺪار 4‪ VB‬ﺣﺘﻰ ﺗﺘﻮاﻓـﻖ ﻣـﻊ ﺗﻘﻨﻴـﺔ ‪ ،COM‬وﻳﺴـﺘﻄﻴﻊ ﺣﻤـﻞ ﺟﻤﻴـﻊ اﻧـﻮاع اﻟﺒﻴﺎﻧـﺎت‬
                                  ‫اﻟﺴﺎﺑﻖ ذآﺮهﺎ ﻣﺜﻞ: ‪ .... Long ،Date ،String‬اﻟﺦ.‬
‫اﻟﺤﺠﻢ اﻟﺬي ﻳﺴﺘﻬﻠﻜﻪ اﻟﻤﺘﻐﻴﺮ ‪ Variant‬هﻮ 61 ﺑﺎﻳﺖ،اﻟﺒﺎﻳﺖ اﻻول ﻳﺤـﺪد ﻧـﻮع اﻟﻘﻴﻤـﺔ‬
‫اﻟﻤﻮﺟﻮدة ﻓﻲ اﻟﻤﺘﻐﻴﺮ، واﻟﺒﺎﻳﺘﺎت ﻣﻦ 2 اﻟﻰ 7 ﻻ ﺗﺴﺘﺨﺪم اﻻ ﻓﻲ ﺣﺎﻟـﺔ آـﻮن اﻟﻘﻴﻤـﺔ‬
‫ﻣﻦ اﻟﻨﻮع ‪ ،Decimal‬اﻣﺎ اﻟﺒﺎﻳﺘـﺎت ﻣـﻦ 8 اﻟـﻰ 51 ﻓﻬـﻲ ﺗﻤﺜـﻞ اﻟﻘﻴﻤـﺔ اﻟﺘـﻲ ﻳﺤﻤﻠﻬـﺎ‬
                                                                           ‫اﻟﻤﺘﻐﻴﺮ.‬
‫اﻟﻤﻴﺰة اﻟﺘﻲ ﺗﺘﻤﻴﺰ ﺑﻬﺎ اﻟﻤﺘﻐﻴﺮات ﻣﻦ ﻧﻮع ‪ Variant‬ﻟﻴﺲ ﻓﻘـﻂ ﻓـﻲ اﻣﻜﺎﻧﻴـﺔ اﺷـﺘﻤﺎﻟﻬﺎ‬
‫ﻋﻠﻰ اﻧﻮاع ﻣﺨﺘﻠﻔﺔ ﻣﻦ اﻟﺒﻴﺎﻧﺎت ﺑﻞ واﺟـﺮاء اﻟﻌﻤﻠﻴـﺎت اﻟﺤﺴـﺎﺑﻴﺔ او اﻟﻤﻨﻄﻘﻴـﺔ ﻋﻠﻴﻬـﺎ،‬
‫ﺣﻴﺚ ﻳﻘﻮم ‪ Visual Basic‬ﺑﺎﺧﺘﺒﺎر ﻧﻮع اﻟﻤﺘﻐﻴﺮات وﻣﻦ ﺛـﻢ اﺟـﺮاء اﻟﻌﻤﻠﻴـﺔ اﻟﺤﺴـﺎﺑﻴﺔ او‬
                                                            ‫اﻟﻤﻨﻄﻘﻴﺔ اﻟﻤﻨﺎﺳﺒﺔ ﻟﻬﺎ:‬

‫‪Dim X As Variant‬‬
‫‪Dim Y As Variant‬‬
‫‪Dim Z As Variant‬‬

‫0002 = ‪X‬‬              ‫‘‬   ‫ﻗﻴﻤﺔ ﻣﻦ اﻟﻨﻮع ‪Integer‬‬
‫)0002(‪Y = CLng‬‬        ‫‘‬   ‫ﻗﻴﻤﺔ ﻣﻦ اﻟﻨﻮع ‪Long‬‬
‫‪Z=X+Y‬‬                 ‫‘‬   ‫ﻗﻴﻤﺔ ﻣﻦ اﻟﻨﻮع ‪Long‬‬
‫)5.2(‪X = CDbl‬‬         ‫‘‬   ‫ﻗﻴﻤﺔ ﻣﻦ اﻟﻨﻮع ‪Double‬‬
‫‪Z=X+Y‬‬                 ‫‘‬   ‫ﻗﻴﻤﺔ ﻣﻦ اﻟﻨﻮع ‪Double‬‬

‫ﻻ ﺗﺤﺎول اﻻﻋﺘﻤﺎد ﻋﻠﻰ اﻟﻄﺮق اﻟﺴﺎﺑﻘﺔ ﺑﺸـﻜﻞ اﺳـﺘﺜﻨﺎﺋﻲ، ﻓﻘـﺪ ﺗﻌﻄﻴـﻚ ﻧﺘـﺎﺋﺞ ﻏﻴـﺮ‬
‫ﻣﺘﻮﻗﻌﺔ، ﻓﻤﺜﻼ اﺳﺘﺨﺪام ﻣﻌﺎﻣﻞ اﻟﺠﻤﻊ + ﻣﻊ ﻣﺘﻐﻴﺮﻳﻦ ﻣﻦ اﻟﻨﻮع ‪ Variant‬ﻳـﺆدي اﻟـﻰ‬
‫ﺟﻤﻌﻬﻤﺎ اذا آﺎﻧﺖ ﻗﻴﻢ ﻋﺪدﻳﺔ، اﻣـﺎ اﻟﺤﺮﻓﻴـﺔ ﻓﺘـﺘﻢ ﻋﻤﻠﻴـﺔ اﻟـﺪﻣﺞ ﺑﻴﻨﻬﻤـﺎ آﺎﺳـﺘﺨﺪام‬
‫ﻣﻌﺎﻣﻞ اﻟـﺪﻣﺞ &، واذا آـﺎن اﺣـﺪ اﻟﻤﺘﻐﻴـﺮﻳﻦ ﺣﺮﻓـﻲ واﻻﺧـﺮ ﻋـﺪدي ﻓﺴـﻴﻘﻮم ‪Visual‬‬
‫‪ Basic‬ﺑﻤﺤﺎوﻟﺔ ﺗﺤﻮﻳﻞ اﻟﻘﻴﻤﺔ اﻟﺤﺮﻓﻴﺔ اﻟﻰ ﻋﺪدﻳـﺔ، وان ﻟـﻢ ﻳﺴـﺘﻄﻊ ﻓﺮﺳـﺎﻟﺔ اﻟﺨﻄـﺄ‬
                                  ‫‪ Type Mismatch‬ﺳﻴﻜﻮن ﻟﻬﺎ ﻧﺼﻴﺐ ﻓﻲ اﻟﻈﻬﻮر:‬

‫‪Dim X As Variant‬‬
‫‪Dim Y As Variant‬‬
‫‪Dim Z As Variant‬‬

‫02 = ‪X‬‬
                                                  ‫28‬


‫"02" = ‪Y‬‬
‫‪Z=X+Y‬‬           ‫04 = ‪‘ Z‬‬
‫"02" = ‪X‬‬
‫‪Z=X+Y‬‬           ‫”0202“ = ‪‘ Z‬‬
‫‪Print Z‬‬
‫02 = ‪X‬‬
‫"‪Y = "abcd‬‬
‫‪Z=X+Y‬‬           ‫رﺳﺎﻟﺔ ﺧﻄﺄ ‘‬

‫اذا ﻓﺘﻨﺖ ﻓﻲ اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪ Variant‬واﻋﺠﺒﺖ ﺑﻬﺎ آﺜﻴﺮا، ﻓﺘﺬآﺮ اﻧﻬـﺎ اﺑﻄـﺄ اﻧـﻮاع‬
‫اﻟﻤﺘﻐﻴــﺮات، ﻓــﻼ ﺗﺤــﺎول اﻻﻋﺘﻤــﺎد ﻋﻠﻴﻬــﺎ اﻻ ﻋﻨــﺪ اﻟﻀــﺮورة اﻟﻘﺼــﻮى او ﻋﻨــﺪ اﻟﺤﺎﺟــﺔ‬
                                              ‫ﻻﺳﺘﺨﺪام اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪.Decimal‬‬
‫ﺗﺴﺘﻄﻴﻊ ﻣﻌﺮﻓﺔ ﻧـﻮع اﻟﻘﻴﻤـﺔ اﻟﻤﻮﺟـﻮدة ﻓـﻲ اﻟﻤﺘﻐﻴـﺮ ﻣـﻦ اﻟﻨـﻮع ‪ Variant‬ﺑﺎﺳـﺘﺨﺪام‬
                                                                       ‫اﻟﺪاﻟﺔ ‪:VarType‬‬

‫‪Dim X As Variant‬‬
‫02 = ‪X‬‬
‫)‪Print VarType(X‬‬        ‫ﺗﻄﺒﻊ 2 وهﻮ اﻟﻨﻮع ‪‘ Integer‬‬
‫"02" = ‪X‬‬
‫‪Print X‬‬                 ‫ﺗﻄﺒﻊ 02 وهﻮ اﻟﻨﻮع ‪‘ String‬‬

‫اذا ﻟﻢ ﺗﺴﻨﺪ أي ﻗﻴﻤﺔ ﻟﻠﻤﺘﻐﻴﺮ ‪ Variant‬ﻓﺎن اﻟﻘﻴﻤﺔ اﻻﺑﺘﺪاﺋﻴﺔ ﻟـﻪ هـﻲ ‪ Empty‬واﻟﺘـﻲ‬
                                            ‫ﺗﺴﺘﻄﻴﻊ اﺧﺘﺒﺎرهﺎ ﺑﺎﻟﺪاﻟﺔ ‪:IsEmpty‬‬

‫‪Dim X As Variant‬‬

‫)‪Print IsEmpty(X‬‬        ‫‪‘ True‬‬
‫"02" = ‪X‬‬
‫)‪Print IsEmpty(X‬‬        ‫‪‘ False‬‬
‫‪X = Empty‬‬
‫)‪Print IsEmpty(X‬‬        ‫‪‘ True‬‬

‫اﻣﺎ اﻟﻘﻴﻤـﺔ ‪ Null‬ﻓﻬـﻲ ﻻ ﺗﻌﻨـﻲ ‪ ،Empty‬ﻻن ‪ Null‬ﻻ ﺗﻌﺘﺒـﺮ ﻗﻴﻤـﺔ ﺧﺎﻟﻴـﺔ ﻓﻬـﻲ ﻗﻴﻤـﺔ‬
                       ‫ﻣﻌﻴﻨﺔ ﺗﺴﺘﺨﺪم ﻓﻲ اﻟﻐﺎﻟﺐ ﻣﻊ ﻗﻮاﻋﺪ اﻟﺒﻴﺎﻧﺎت ‪:DataBases‬‬
                                                 ‫38‬


‫‪Dim X As Variant‬‬

‫‪X = Null‬‬
‫)‪Print IsNull(X‬‬        ‫‪‘ True‬‬
‫)‪Print VarType(X‬‬       ‫ﺗﻄﺒﻊ 1 وهﻮ اﻟﻨﻮع ‪‘ Null‬‬

‫واﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪ Variant‬ﻳﻤﻜﻦ ﻟﻬﺎ ان ﺗﺤﺘﻮي آﺎﺋﻨـﺎت ‪ ،Objects‬ﻟﻜـﻦ ﻻ ﺗﻨﺴـﻰ‬
‫اﺳــﺘﺨﺪام اﻟﻜﻠﻤــﺔ اﻟﻤﺤﺠــﻮزة ‪ Set‬ﻋﻨــﺪ اﺳــﻨﺎد ﻗﻴﻤــﺔ آــﺎﺋﻦ اﻟــﻰ ﻣﺘﻐﻴــﺮ، واذا اردت‬
‫اﻻﺳﺘﻌﻼم ﻋﻦ ﻧﻮع اﻟﻤﺘﻐﻴﺮ، ﻓﻼ ﺗﺴﺘﺨﺪم ‪ VarType‬ﻓﻬﻲ ﺗﻌﻄﻲ ﻧﻮع ﻗﻴﻤـﺔ اﻟﺨﺎﺻـﻴﺔ‬
                 ‫اﻻﻓﺘﺮاﺿﻴﺔ ﻟﻠﻜﺎﺋﻦ، اﻣﺎ اﻟﺪاﻟﺔ ‪ IsObject‬ﻓﻬﻲ ﺗﻔﻲ ﺑﺎﻟﻐﺮض اﻟﻤﻄﻠﻮب:‬

‫‪Dim X As Variant‬‬

‫1‪Set X = Text‬‬
‫)‪Print IsObject(X‬‬      ‫‪‘ True‬‬
‫"اﻟﻨﺺ" = ‪X.Text‬‬        ‫‪‘ Text1.Text‬‬

‫اﺧﻴﺮا، اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪ Variant‬ﻳﻤﻜﻦ ﻟﻬﺎ ان ﺗﺤﻮي ﻣﺼﻔﻮﻓﺎت آﻤـﺎ ﺳـﻴﺄﺗﻲ ﻓـﻲ‬
‫ﻓﻘﺮة "اﻟﺘﺮآﻴﺒﺎت واﻟﻤﺼﻔﻮﻓﺎت"، وﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﺘﺮآﻴﺒﺎت ﻣﻦ اﻟﻨﻮع ‪ UDT‬ﻓﻴﻤﻜﻦ اﺣﺘﻀـﺎﻧﻬﺎ‬
   ‫ـ‬    ‫ـ‬              ‫ـ‬    ‫ـ‬
‫ﻓـﻲ اﻟﻤﺘﻐﻴـﺮات ‪ Variant‬ﺷـﺮﻳﻄﺔ ان ﻳﻜـﻮن اﻟﺘﺮآﻴـﺐ ﻣـﻦ اﻟﻨـﻮع ‪ Public‬ﻣﺼـﺮح ﻋﻠـﻰ‬
                                ‫ـ‬       ‫ـ‬          ‫ـ‬             ‫ـ‬         ‫ـ‬
‫ﻣﺴﺘﻮى اﻟﻮﺣﺪة اﻟﺒﺮﻣﺠﻴﺔ ‪ ،Module‬أو ﻋﻠـﻰ ﻣﺴـﺘﻮى وﺣـﺪة اﻟﻔﺌـﺎت اﻟﻌﺎﻣـﺔ ‪Public‬‬
                                                                    ‫‪.Classes‬‬

                                                                           ‫اﻟﺜﻮاﺑﺖ‬
‫اﺑﺴﻂ اﻧﻮاع اﻟﺜﻮاﺑـﺖ هـﻲ اﻟﺜﻮاﺑـﺖ اﻟﻌﺪدﻳـﺔ واﻟﺘـﻲ ﻳﻤﻜﻨـﻚ آﺘﺎﺑﺘﻬـﺎ ﻣﺒﺎﺷـﺮة ﺑﺎﻟﻨﻈـﺎم‬
                    ‫ـ‬            ‫ـ‬           ‫ـ‬         ‫ـ‬
‫اﻟﻌﺸــﺮي ‪ Decimal‬او ﺑﺎﺿــﺎﻓﺔ اﻟﺒﺎدﺋــﺔ ‪ &H‬ﻟﻠﻨﻈــﺎم اﻟﺴﺘﻌﺸــﺮي ‪ Hexadecimal‬او‬‫ـ‬
                                                       ‫اﻟﺒﺎدﺋﺔ ‪ &O‬ﻟﻠﻨﻈﺎم اﻟﺜﻤﺎﻧﻲ:‬

‫ﺟﻤﻴﻊ اﻻﻋﺪاد اﻟﺘﺎﻟﻴﺔ ﺗﺴﺎوي 51 ‘‬
‫51 ‪Print‬‬
‫‪Print &HF‬‬
‫71‪Print &O‬‬

‫ﻣﻦ اﻟﻀﺮوري ان اﻧﺒﻪ هﻨﺎ ﺑﺎن ﺟﻤﻴـﻊ اﻻﻋـﺪاد اﻟﻤﺴـﺘﺨﺪﻣﺔ ﻓـﻲ اﻟﻨﻈـﺎم اﻟﺴﺘﻌﺸـﺮي‬
‫‪ Hexadecimal‬آـ 0، 1، 2 ....، ‪ F ،E‬واﻟﻨﻈﺎم اﻟﺜﻤﺎﻧﻲ ‪ Octal‬واﻟﺘﻲ ﺗﻜﺘﺒﻬﺎ ﻓﻲ اآﻮادك‬
                                                   ‫48‬


‫ﺗﻌﺘﺒﺮ ﻓﻲ ﻧﻈﺮ ‪ Visual Basic‬اﻋﺪاد ﻣﻦ اﻟﻨﻮع ‪ Integer‬ﻣﺎﻟﻢ ﺗﻀﻴﻒ اﻟﺮﻣﺰ & ﺑﻌـﺪ ﻧﻬﺎﻳـﺔ‬
‫اﻟﻌﺪد ﻓﺴﻴﻜﻮن ﻣﻦ اﻟﻨﻮع ‪ ،Long‬ﻗﺪ ﺗﻜﻮن ﺟﻤﻠﺘﻲ اﻟﺴﺎﺑﻘﺔ ﻟﻴﺴﺖ ذات اهﻤﻴﺔ آﺒﻴـﺮة‬
         ‫ﻋﻨﺪ ﻣﻌﻈﻢ اﻟﻤﺒﺮﻣﺠﻴﻦ اﻟﻤﺒﺘﺪﺋﻴﻦ، ﻟﺬﻟﻚ ﻋﻠﻲ ان اﺷﺪ اﻧﺘﺒﺎهﻬﻢ ﺑﻬﺬا اﻟﻤﺜﺎل:‬

‫ﺳﺘﻌﺸﺮي ‘‬
‫04416 = 000‪‘ &HF‬‬
‫000‪Print &HF‬‬            ‫هﻨﺎ ﺗﻄﺒﻊ 6904- ‘‬
‫&000‪Print &HF‬‬           ‫هﻨﺎ ﺗﻄﺒﻊ 04416 ‘‬
‫ﺛﻤﺎﻧﻲ‘‬
‫04416 = 000071‪‘&O‬‬
‫000071‪Print &O‬‬          ‫هﻨﺎ ﺗﻄﺒﻊ 6904-‘‬
‫&000071‪Print &O‬‬         ‫هﻨﺎ ﺗﻄﺒﻊ 04416‘‬

  ‫ـ ـ‬              ‫ـ‬     ‫ـ‬
‫ﺑﻌ ـﺪ اﻟﺜﻮاﺑـﺖ اﻟﻌﺪدﻳ ـﺔ ﺗ ـﺄﺗﻲ اﻟﺜﻮاﺑ ـﺖ اﻟﺤﺮﻓﻴـﺔ ‪ ،Strings‬واﻟﺘ ـﻲ ﻳﺸ ـﺘﺮط آﺘﺎﺑﺘﻬ ـﺎ ﺑ ـﻴﻦ‬
                                          ‫ـ‬        ‫ـ‬           ‫ـ ـ‬            ‫ـ‬        ‫ـ‬
‫ﻋﻼﻣﺘﻲ اﻟﺘﻨﺼﻴﺺ اﻟﻤﺰدوﺟﺔ " و "، وﻻﺳﺘﺨﺪام ﻋﻼﻣﺔ اﻟﺘﻨﺼﻴﺺ " ﻓـﻲ ﻧﻔـﺲ اﻟﺜﺎﺑـﺖ‬
                                                                  ‫اﻟﺤﺮﻓﻲ، آﺮرهﺎ ﻣﺮﺗﻴﻦ:‬

‫ﻣﺨﺮﺟﺎت اﻟﻜﻮد اﻟﺘﺎﻟﻲ هﻲ: ‘‬
‫ﺛﺎﺑﺖ ﺣﺮﻓﻲ ‘‬
‫654”321 ‘‬
‫“‘‬
‫"ﺛﺎﺑﺖ ﺣﺮﻓﻲ" ‪Print‬‬
‫"654""321" ‪Print‬‬
‫"""" ‪Print‬‬

‫ﻓﻜﺮة اﻟﺜﻮاﺑﺖ اﻟﻤﺴﻤﺎة ﺷﺒﻴﻬﻪ ﺑﻔﻜﺮة اﻟﻤﺘﻐﻴﺮات، وﻳﻜﻤﻦ اﻟﻔـﺮق ﺑﻴﻨﻬﻤـﺎ ﻓـﻲ أن ﻗـﻴﻢ‬
   ‫ـ‬         ‫ـ‬             ‫ـ‬          ‫ـ‬             ‫ـ‬            ‫ـ‬
‫اﻟﺜﻮاﺑـﺖ ﻻﻳﻤﻜﻨـﻚ ﺗﻌـﺪﻳﻠﻬﺎ وﻗـﺖ اﻟﺘﻨﻔﻴـﺬ ﻻﻧﻬـﺎ ﻗـﻴﻢ ﻟﻴﺴـﺖ ﻣﻮﺟـﻮدة ﺑﺎﻟـﺬاآﺮة آﻘـﻴﻢ‬
‫اﻟﻤﺘﻐﻴﺮات، واﻧﻤﺎ ﻳﺘﻢ اﺳﺘﺒﺪال هﺬﻩ اﻻﺳﻤﺎء ﺑﻘﻴﻤﺘﻬﺎ اﻟﻔﻌﻠﻴﺔ ﻓﻲ اﻟﻜـﻮد اﺛﻨـﺎء ﻋﻤﻠﻴـﺔ‬
     ‫اﻟﺘﺮﺟﻤﺔ ‪ ،Compiling‬ﻓﺎﻟﺜﻮاﺑﺖ ﺗﺤﻔﻆ ﻣﺒﺎﺷﺮة ﻓﻲ اﻟﻤﻠﻒ اﻟﺘﻨﻔﻴﺬي ‪ EXE‬ﻟﻠﺒﺮﻧﺎﻣﺞ.‬
                               ‫ﺗﺴﺘﻄﻴﻊ ﺗﻌﺮﻳﻒ ﺛﺎﺑﺖ ﺟﺪﻳﺪ ﺑﺎﺳﺘﺨﺪام اﻟﻌﺒﺎرة ‪:Const‬‬

‫41.3 = ‪Const PI‬‬

‫‪Print PI‬‬

                              ‫آﻤﺎ ﻳﻔﻀﻞ ﺗﻌﺮﻳﻒ ﻧﻮع اﻟﺜﺎﺑﺖ ﻟﺰﻳﺎدة ﺳﺮﻋﺔ اﻟﺘﻌﺎﻣﻞ ﻣﻌﻪ:‬
                                                ‫58‬


‫41.3 = ‪Const PI As Double‬‬
‫”ﺗﺮآﻲ اﻟﻌﺴﻴﺮي“ = ‪Const PROGRAMMER_NAME As String‬‬
‫&‪Const SPECIAL_VALUE As Long = &H32FE‬‬

‫ارﺟﻮ ان ﺗﻠﺘﺰم ﺑﺎﻟﻘﻴﻤﺔ اﻟﻤﻨﺎﺳﺒﺔ ﻋﻨﺪ ﺗﺤﺪﻳـﺪ ﻧـﻮع اﻟﺜﺎﺑـﺖ، ﻓـﻼ ﺗﺴـﻨﺪ ﻗﻴﻤـﺔ ﻋﺸـﺮﻳﺔ‬
‫ﻟﺜﺎﺑﺖ ﺻﺤﻴﺢ -آﺎﻟﻨﻮع ‪ Integer‬ﻣـﺜﻼ، ﻻن ﻗﻴﻤـﺔ اﻟﺜﺎﺑـﺖ ﺳـﺘﺘﻐﻴﺮ ان ﻟـﻢ ﺗﻈﻬـﺮ رﺳـﺎﻟﺔ‬
                                                        ‫اﻟﺨﻄﺄ ‪:Type Mismatch‬‬

‫اﻟﻘﻴﻤﺔ ﺳﺘﻜﻮن 3 ‘ 41.3 = ‪Const PI As Integer‬‬
‫ﺳﺘﻈﻬﺮ رﺳﺎﻟﺔ ﺧﻄﺄ ‘ ”‪Const PI As Integer = “abc‬‬

‫اﺧﻴﺮا، ﻗﺎﺑﻠﻴﺔ اﻟﺮؤﻳﺔ اﻻﻓﺘﺮاﺿﻴﺔ ﻟﻠﺜﻮاﺑﺖ ﺗﻜﻮن ‪ Private‬ﻋﻠﻰ ﻣﺴﺘﻮى اﻻﺟﺮاء اﻟﻤﺤﻠﻲ،‬
‫او ﻋﻠﻰ ﻣﺴﺘﻮى ﻧﺎﻓﺬة اﻟﻨﻤﻮذج او اﻟﻔﺌﺔ اذا ﺻﺮح ﻋﻨﻬﺎ ﻓﻲ ﻣﻨﻄﻘﺔ اﻻﻋﻼﻧـﺎت اﻟﻌﺎﻣـﺔ،‬
‫او ﻋﻠﻰ ﻣﺴـﺘﻮى اﻟﻤﺸـﺮوع اذا ﺻـﺮح ﻋﻨﻬـﺎ ﻓـﻲ ﻣﻠﻔـﺎت اﻟﺒﺮﻣﺠـﺔ ‪ .BAS‬ﻣـﻊ ﺗﻀـﻤﻴﻦ‬
                                                     ‫اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪:Public‬‬

‫41.3 = ‪Public Const PI As Double‬‬



                                                       ‫اﻟﺘﺮآﻴﺒﺎت واﻟﻤﺼﻔﻮﻓﺎت‬
‫ﺑﺎﻻﺿــﺎﻓﺔ اﻟــﻰ اﻧــﻮاع اﻟﻤﺘﻐﻴــﺮات اﻟﺴــﺎﺑﻘﺔ، ﺗﺴــﺘﻄﻴﻊ ﺗﺨﺼــﻴﺺ اﻧــﻮاع ﺟﺪﻳــﺪة ﺗﻌــﺮف‬
‫ﺑﺎﻟﺘﺮآﻴﺒﺎت، آﻤﺎ ﻳﻤﻜﻨﻚ رﺑﻂ ﺳﻠﺴﻠﺔ ﻣﻦ اﻟﻤﺘﻐﻴﺮات ﻓﻲ ﻣﺼﻔﻮﻓﺎت اﺣﺎدﻳﺔ او ﻣﺘﻌـﺪدة‬
                                                                               ‫اﻻﺑﻌﺎد.‬

                                                                ‫ﺗﺮآﻴﺒﺎت ‪Enum‬‬
‫ﻳﻤﻜﻨﻚ ﺗﻌﺮﻳﻒ ﻧﻮع ﺟﺪﻳﺪ ﻣﻦ اﻟﻤﺘﻐﻴﺮات ﺑﺤﻴﺚ ﻳﺤﺘﻮي ﻋﻠﻰ ﻗﻴﻤـﺔ ﻣـﻦ ﻣﺠﻤﻮﻋـﺔ ﻗـﻴﻢ‬
‫ﺗﻌــﺮف ﺑﺎﻟـــ ‪ .Enumeration‬ﺗﺴــﺘﻄﻴﻊ اﺳــﺘﺨﺪام اﻟﻜﻠﻤــﺔ اﻟﻤﺤﺠــﻮزة ‪ Enum‬ﻟﺘﻌﺮﻳــﻒ‬
‫اﻟﺘﺮآﻴﺐ ﺷﺮﻳﻄﺔ ان ﻳﻜﻮن ﻓﻲ ﻣﻨﻄﻘﺔ اﻻﻋﻼﻧﺎت اﻟﻌﺎﻣﺔ، هﺬا ﻣﺜﺎل ﻳﻌﺮف ﺗﺮآﻴـﺐ ﻷﻳـﺎم‬
                                                                     ‫اﻻﺳﺒﻮع:‬

‫‪Private Enum enmDay‬‬
   ‫‪Saturday‬‬
   ‫‪SunDay‬‬
   ‫‪MonDay‬‬
                                           ‫68‬


  ‫‪TuesDay‬‬
  ‫‪Wednessday‬‬
  ‫‪Thursday‬‬
  ‫‪Friday‬‬
‫‪End Enum‬‬

        ‫واﻻن ﻳﻤﻜﻨﻚ اﺳﺘﺨﺪام اﻟﺘﺮآﻴﺐ اﻟﺴﺎﺑﻖ ﻟﺘﻌﺮﻳﻒ اﻧﻮاع ﺟﺪﻳﺪة ﻣﻦ اﻟﻤﺘﻐﻴﺮات:‬

‫‪Dim X As enmDay‬‬
‫‪Dim Y As enmDay‬‬

‫‪X = Saturday‬‬
‫‪Y=X‬‬

                    ‫او ﺣﺘﻰ اﺳﺘﺨﺪاﻣﻬﺎ ﻻﺳﺘﻘﺒﺎل اﻟﻤﺘﻐﻴﺮات ﻓﻲ اﻋﻠﻰ اﻻﺟﺮاءات:‬

‫)‪Private Sub MySub(TheDay As enmDay‬‬
   ‫‪If TheDay = Friday Then‬‬
      ‫"اﺟﺎزة" ‪MsgBox‬‬
      ‫‪Exit Sub‬‬
   ‫‪End If‬‬
‫‪End Sub‬‬

‫ﺣﻘﻴﻘﺔ اﻟﻤﺘﻐﻴـﺮات ﻣـﻦ اﻟﻨـﻮع ﺗﺮآﻴﺒـﺎت ‪ Enum‬ﻣـﺎهﻲ اﻻ ﻣﺘﻐﻴـﺮات ﻋﺪدﻳـﺔ ﻣـﻦ اﻟﻨـﻮع‬
                        ‫‪ Long‬ﻓﺘﺴﺘﻄﻴﻊ اﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ آﻤﺎ ﻟﻮ آﺎﻧﺖ ﻣﺘﻐﻴﺮات ﻋﺪدﻳﺔ:‬

‫‪Dim X As enmDay‬‬

‫‪X = Saturday‬‬
‫‪Print X‬‬
‫1+‪X=X‬‬
‫‪Print X‬‬

‫آﻤﺎ ﺗﻼﺣﻆ، ﻳﺒﺪأ ﺗﺮﻗﻴﻢ ﻋﻨﺎﺻﺮ اﻟﺘﺮآﻴﺐ ﻣﻦ اﻟﻌﺪد 0، وﻟﺘﺨﺼﻴﺺ ﻗﻴﻢ ﻣﻦ ﻋﻨﺪك، ارﺟـﻊ‬
                                    ‫اﻟﻰ ﺗﻌﺮﻳﻒ اﻟﺘﺮآﻴﺐ وﺿﻊ اﻟﻘﻴﻢ ﻣﻦ ﻋﻨﺪك:‬
                                           87


Private Enum enmDay
   Saturday = 20
   SunDay = 30
   MonDay
   TuesDay
   Wednessday
   Thursday
   Friday
End Enum

                                .1 ‫ﻣﻊ اﻟﻌﻠﻢ ان ﻣﻘﺪار اﻟﺰﻳﺎدة ﻟﺒﺎﻗﻲ اﻟﻌﻨﺎﺻﺮ ﺗﻜﻮن‬

                                                UDT ‫ﺗﺮآﻴﺒﺎت ﻣﻦ اﻟﻨﻮع‬
User Defined ‫ﻳﻌﺮف هﺬا اﻟﻨﻮع ﻣﻦ اﻟﺘﺮآﻴﺒﺎت ﺑﺎﻻﻧﻮاع اﻟﻤﻌﺮﻓﺔ ﻣﻦ ﻗﺒـﻞ اﻟﻤﺴـﺘﺨﺪم‬
،‫ ﺣﻴﺚ ﺗﻤﻜﻨﻚ هﺬﻩ اﻟﺘﺮآﻴﺒﺎت ﻣﻦ اﻻﺣﺘـﻮاء ﻋﻠـﻰ اﻧـﻮاع ﻣﺨﺘﻠﻔـﺔ ﻣـﻦ اﻟﺒﻴﺎﻧـﺎت‬Types
                              :‫ ﻟﺘﻌﺮﻳﻒ ﺗﺮآﻴﺐ ﺟﺪﻳﺪ‬Type ‫اﺳﺘﺨﺪم اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة‬

Private Type typPerson
   sName As String
   bSingle As Boolean
   iAge As Integer
End Type

                                 :‫وﻳﻤﻜﻨﻚ اﺳﺘﺨﺪاﻣﻪ ﻣﺒﺎﺷﺮة آﻤﺎ ﻓﻲ هﺬا اﻟﻜﻮد‬

Dim Turki As typPerson
Dim Ali As typPerson

Turki.sName = "‫"ﺗﺮآﻲ اﻟﻌﺴﻴﺮي‬
Turki.iAge = 99
Turki.bSingle = True

Ali.sName = "‫"ﻋﻠﻲ اﻟﻌﻠﻲ‬
Ali.iAge = 35
Ali.bSingle = False
                                               ‫88‬


                  ‫ﺑﻞ ﻳﻤﻜﻨﻚ ﻧﺴﺦ آﺂﻓﺔ ﻗﻴﻢ اﻟﺘﺮآﻴﺐ اﻟﻰ ﺗﺮآﻴﺐ ﺁﺧﺮ ﻣﻦ ﻧﻔﺲ اﻟﻨﻮع:‬

‫‪Ali = Turki‬‬
‫‪Print Ali.sName‬‬

                                ‫وﻟﻤﻌﺮﻓﺔ ﺣﺠﻢ اﻟﺘﺮآﻴﺐ، ﻓﺎﻟﺪاﻟﺔ ‪ LenB‬ﺗﻔﻲ ﺑﺎﻟﻐﺮض:‬

‫)‪Print LenB (Turki‬‬

                      ‫ﻻ ﺗﻨﺴﻰ اﻧﻪ ﻳﻤﻜﻦ ﻟﻠﺘﺮآﻴﺒﺎت ان ﺗﺤﺘﻮي ﻋﻠﻰ ﺗﺮآﻴﺒﺎت اﺧﺮى:‬

‫‪Private Type typAdress‬‬
   ‫‪sCountrey As String‬‬
   ‫‪sCity As String‬‬
‫‪End Type‬‬

‫‪Private Type typPerson‬‬
   ‫‪sName As String‬‬
   ‫‪bSingle As Boolean‬‬
   ‫‪iAge As Integer‬‬
   ‫‪Address As typAdress‬‬
‫‪End Type‬‬

           ‫اﻟﻮﺻﻮل اﻟﻰ ﻋﻨﺎﺻﺮ اﻟﺘﺮآﻴﺐ اﻟﻤﺤﻀﻦ ﻳﺘﻢ ﻣﻦ ﺧﻼل اﻟﺘﺮآﻴﺐ اﻟﺤﺎﺿﻦ ﻟﻬﺎ:‬

‫‪Dim Turki As typPerson‬‬

‫"ﺗﺮآﻲ اﻟﻌﺴﻴﺮي" = ‪Turki.sName‬‬
‫99 = ‪Turki.iAge‬‬
‫‪Turki.bSingle = True‬‬
‫"اﻟﻈﻬﺮان" = ‪Turki.Address.sCity‬‬
‫"اﻟﻤﻤﻠﻜﺔ اﻟﻌﺮﺑﻴﺔ اﻟﺴﻌﻮدﻳﺔ" = ‪Turki.Address.sCountrey‬‬

‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻘﺎﺑﻠﻴﺔ اﻟﺮؤﻳﺔ ﻓﻠﻦ ﺗﺴﺘﻄﻴﻊ ﺗﻌﺮﻳﻒ اﻟﺘﺮآﻴﺒـﺎت ﺑﺎﺳـﺘﺨﺪام اﻟﻜﻠﻤـﺔ اﻟﻤﺤﺠـﻮزة‬
 ‫ـ‬            ‫ـ‬     ‫ـ‬       ‫ـ‬       ‫ـ‬                           ‫ـ‬       ‫ـ‬
‫‪ Public‬اﻻ ﻓـﻲ اﻟﻔﺌ ـﺎت ‪ ،Classes‬واذا آﻨ ـﺖ ﻋﻨﻴ ـﺪا واﺻ ـﺮرت ﻋﻠ ـﻰ اﺳ ـﺘﺨﺪام اﻟﻜﻠﻤ ـﺔ‬
‫اﻟﻤﺤﺠﻮزة ‪ Public‬ﻓـﻲ ﻣﻠﻔـﺎت اﻟﺒﺮﻣﺠـﺔ ‪ ،BAS‬ﻓﺴﻴﺴـﻤﺢ ﻟـﻚ ‪ Visual Basic‬ﺑﺘﺼـﺮﻳﺢ‬
                                              ‫98‬


‫ﻣﺘﻐﻴﺮات ﺟﺪﻳﺪة ﻣﻦ اﻟﺘﺮآﻴﺐ اﻟﻌﺎم، وﻟﻜﻨﻚ ﺳﺘﺼـﺎب ﺑﺨﻴﺒـﺔ اﻣـﻞ آﺒﻴـﺮة ان ﻋﻠﻤـﺖ ان‬
‫اﻻﺟﺮاءت اﻟﻤﺼﺮﺣﺔ ﻋﻠﻰ ﻣﺴﺘﻮى اﻟﻮﺣﺪة ‪ Public‬ﻻ ﻳﻤﻜﻨﻚ اﺳﺘﺨﺪام هﺬﻩ اﻟﺘﺮآﻴﺒـﺎت‬
                                             ‫آﻘﻴﻢ ﻣﺴﺘﻘﺒﻠﺔ ‪ Parameters‬ﻟﻬﺎ:‬

‫ﻏﻴﺮ ﻣﻤﻜﻦ ‘ )‪Public Sub MySub(P As typPerson‬‬
‫ﻣﻤﻜﻦ ‘ )‪Private Sub MySub(P As typPerson‬‬
‫ﻣﻤﻜﻦ ‘ )‪Freind Sub MySub(P As typPerson‬‬

 ‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻔﺌﺎت ‪ ،Classes‬ﺗﺴﺘﻄﻴﻊ ﺗﻌﺮﻳﻒ اﻟﺘﺮآﻴﺒـﺎت ﻋﻠـﻰ ﻣﺴـﺘﻮى‬          ‫ﻣﻼﺣﻈﺔ:‬
                           ‫ـ‬        ‫ـ‬       ‫ـ‬           ‫ـ‬
 ‫‪ Public‬ﺷ ـﺮﻳﻄﺔ ان ﺗﻜ ـﻮن ﻗﻴﻤ ـﺔ اﻟﺨﺎﺻ ـﻴﺔ ‪ Instancing‬ﻻ ﺗﺴــﺎوي -1‬
                                                           ‫‪.Private‬‬


                                                                ‫اﻟﻤﺼﻔﻮﻓﺎت‬
‫ﻳﻤﻜﻨﻚ ‪ Visual Basic‬ﻣﻦ اﻧﺸﺎء واﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺼﻔﻮﻓﺎت ‪ Arrays‬ﺳﻮاء آﺎﻧـﺖ اﺣﺎدﻳـﺔ‬
                                 ‫اﻟﺒﻌﺪ او ﻣﺘﻌﺪدة اﻻﺑﻌﺎد –ﻗﺪ ﺗﺼﻞ اﻟﻰ 06 ﺑﻌﺪا:‬

‫‪Dim OneDim (99) As Intger‬‬           ‫001 ﻋﻨﺼﺮ ‘‬
‫‪Dim TwoDim (4, 9) As Integer‬‬        ‫ﺛﻨﺎﺋﻴﺔ اﻻﺑﻌﺎد ‘‬
‫‪Dim ThreeDim (2, 2, 2) As Integer‬‬   ‫ﺛﻼﺛﻴﺔ اﻻﺑﻌﺎد ‘‬

‫‪Dim OneDArray(0 To 10) As String‬‬
‫‪Dim TwoDArray(0 To 10, 0 To 10) As Long‬‬
‫‪Dim OneDArray(15 To 22) As String‬‬

‫ﺗﺴﺘﻄﻴﻊ اﻟﺒﺪء ﻓﻲ ﻋﻤﻠﻴﺔ اﺳﻨﺎد اﻟﻘﻴﻢ ﺑﻤﺠﺮد ﺗﺼﺮﻳﺢ اﻟﻤﺼﻔﻮﻓﺔ ﻣﻊ اﻟﻌﻠﻢ ان ﻓﻬـﺮس‬
‫اﻟﻤﺼﻔﻮﻓﺔ ‪ Array Index‬ﻳﺒـﺪأ ﻣـﻦ ﺻـﻔﺮ ﻣـﺎﻟﻢ ﺗﺴـﺘﺨﺪم اﻟﻜﻠﻤـﺔ اﻟﻤﺤﺠـﻮزة ‪Option‬‬
         ‫1 ‪ Base‬ﻓﻲ ﻣﻨﻄﻘﺔ اﻻﻋﻼﻧﺎت اﻟﻌﺎﻣﺔ ﻟﻠﻮﺣﺪة اﻟﺒﺮﻣﺠﻴﺔ ﻓﺎﻧﻪ ﺳﻴﺒﺪأ ﺑﻮاﺣﺪ:‬

‫001 = )0( ‪OneDim‬‬
‫002 = )1( ‪OneDim‬‬
‫))1( ‪TwoDim (0, 0) = (100, OneDim (0) + OneDim‬‬
                                                 ‫09‬


 ‫رﻏﻢ ان ﺑﺪء ﺗﺮﻗﻴﻢ ﻓﻬﺮس اﻟﻤﺼﻔﻮﻓﺔ ﻳﻤﻜﻦ ان ﻳﺒﺪأ ﺑﻮاﺣﺪ، اﻻ اﻧﻨـﻲ ﻻ‬              ‫ﻣﻼﺣﻈﺔ:‬
                 ‫ـ‬                   ‫ـ‬                             ‫ـ‬
 ‫اﺣﺒ ـﺬ ﻟﻤﺒﺮﻣﺠــﻲ ‪ Visual Basic‬ﻓﻌ ـﻞ ذﻟــﻚ، ﻓﻌﻨــﺪ ﻧﻘ ـﻞ اﻻآــﻮاد ﺑــﻴﻦ‬
 ‫اﻟﻤﺸﺎرﻳﻊ اﻟﻤﺨﺘﻠﻔﺔ او اﻟﻮﺣﺪات اﻟﺒﺮﻣﺠﻴﺔ اﻟﻤﺨﺘﻠﻔﺔ ﻗﺪ ﻻ ﻳـﺘﻢ ﺗﻔﻌﻴـﻞ‬
 ‫اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠـﻮزة 1 ‪ Option Base‬ﻣﻤـﺎ ﻳﺘﺮﺗـﺐ ﻋﻨـﻪ ﻇﻬـﻮر ﻋﺸـﺮات‬
                                                      ‫اﻻﺧﻄﺎء اﻟﺒﺮﻣﺠﻴﺔ.‬

‫وﻟﻤﻌﺮﻓﺔ رﻗﻢ اﻟﻌﻨﺼﺮ اﻻول اﺳﺘﺨﺪم اﻟﺪاﻟﺔ ‪ LBound‬ﺑﻴﻨﻤﺎ اﻟﺪاﻟﺔ ‪ UBound‬ﺗﻌـﻮد ﺑـﺮﻗﻢ‬
                                                               ‫اﻟﻌﻨﺼﺮ اﻻﺧﻴﺮ:‬

‫‪Dim lCounter As Long‬‬

‫)‪For lCounter = LBound (OneDim) To UBound (OneDim‬‬
       ‫)‪Print OneDim (lCounter‬‬
‫‪Next‬‬

‫اﻣﺎ ﻣﻊ اﻟﻤﺼﻔﻮﻓﺎت اﻟﻤﺘﻌﺪدة اﻻﺑﻌﺎد، ﻋﻠﻴﻚ ارﺳﺎل رﻗﻢ اﻟﺒﻌﺪ ﻣـﻊ اﻟـﺪاﻟﺘﻴﻦ ‪ UBound‬و‬
                                                                   ‫‪:LBound‬‬

‫)‪Print UBound (TwoDim‬‬          ‫ﺗﻄﺒﻊ 4 ‘‬
‫)1 ,‪Print UBound (TwoDim‬‬       ‫ﺗﻄﺒﻊ 4 ‘‬
‫)2 ,‪Print UBound (TwoDim‬‬       ‫ﺗﻄﺒﻊ 9 ‘‬

‫اﻟﻤﺼﻔﻮﻓﺎت اﻟﺴﺎﺑﻘﺔ ‪ TwoDim ،OneDim‬و ‪ ThreeDim‬هﻲ ﻣﺼﻔﻮﻓﺎت ﺳﺘﺎﺗﻴﻜﻴﺔ أي‬
‫ﺛﺎﺑﺘــﺔ اﻟﺤﺠــﻢ ﻻ ﺗﺘﻐﻴــﺮ ﻓــﻲ وﻗــﺖ اﻟﺘﻨﻔﻴــﺬ، ﻟــﺬﻟﻚ ﻓﺎﻟﻤﺮوﻧــﺔ اﻟﺤﻘﻴﻘــﺔ ﺳــﺘﻜﻮن ﻣــﻊ‬
‫اﻟﻤﺼــﻔﻮﻓﺎت اﻟﺪﻳﻨﺎﻣﻴﻜﻴــﺔ ‪ Dynamic Arrays‬اﻟﺘــﻲ ﺗﺘــﻴﺢ ﻟــﻚ اﻟــﺘﺤﻜﻢ ﻓــﻲ ﺣﺠــﻢ‬
                  ‫اﻟﻤﺼﻔﻮﻓﺎت آﻠﻤﺎ دﻋﺖ اﻟﺤﺎﺟﺔ، وﺗﺼﺮﻳﺤﻬﺎ ﻳﻜﻮن ﺑﺪون ذآﺮ ﺣﺠﻤﻬﺎ:‬

‫‪Dim DynamicArray () As String‬‬

‫ﻗﺒﻞ ان ﺗﺒﺪأ ﻓﻲ ﻋﻤﻠﻴﺔ اﺳﻨﺎد اﻟﻘﻴﻢ، ﻋﻠﻴﻚ اﺳﺘﺨﺪام اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠـﻮزة ‪ ReDim‬اوﻻ‬
                                                           ‫ﻣﻊ ذآﺮ اﻟﺤﺠﻢ:‬

‫)2( ‪ReDim DynamicArray‬‬

‫”ﻧﻮرﻩ“ = )0( ‪DynamicArray‬‬
                                                  ‫19‬


‫”اﻟﻌﻨﻮد“ = )1( ‪DynamicArray‬‬
‫”اﻟﻬﻨﻮف“ = )2( ‪DynamicArray‬‬

‫ﻟﻮ اردت زﻳﺎدة او ﺗﻘﻠﻴﺺ ﺣﺠﻢ اﻟﻤﺼﻔﻮﻓﺔ، اﺳﺘﺨﺪم ‪ ReDim‬ﻣﺮة اﺧﺮى وﻋﻠﻴﻚ ﻣﻌﺮﻓـﺔ‬
                                 ‫ان ﺟﻤﻴﻊ ﻣﺤﺘﻮﻳﺎت اﻟﻤﺼﻔﻮﻓﺔ ﺳﻮف ﺗﻠﻐﻰ:‬

‫)4( ‪ReDim DynamicArray‬‬

‫”ﺟﻨﺎن“ = )3( ‪DynamicArray‬‬
‫”زﻏﻠﻮل!“ = )4( ‪DynamicArray‬‬

‫)4( ‪Print DynamicArray‬‬          ‫ﺗﻄﺒﻊ "زﻏﻠﻮل!" ‘‬
‫)2( ‪Print DynamicArray‬‬          ‫ﻻ ﺗﻄﺒﻊ ﺷﻴﺊ ‘‬

  ‫ـ‬        ‫ـ‬         ‫ـ‬         ‫ـ‬
‫واذا رﻏﺒ ـﺖ ﺑﺘﻐﻴﻴ ـﺮ ﺣﺠ ـﻢ اﻟﻤﺼ ـﻔﻮﻓﺔ دون اﻟﻤﺨ ـﺎﻃﺮة ﺑﻔﻘ ـﺪ اﻟﺒﻴﺎﻧ ـﺎت اﻟﻤﻮﺟ ـﻮدة ﻓﻴﻬ ـﺎ،‬
                                         ‫ـ‬              ‫ـ‬       ‫ـ‬     ‫ـ‬        ‫ـ‬
                                       ‫ﻓﺎﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ Preserve‬ﺟﺎهﺰة ﻟﻼﺳﺘﺨﺪام:‬

‫)4( ‪ReDim Preserve DynamicArray‬‬

‫”ﺟﻨﺎن“ = )3( ‪DynamicArray‬‬
‫”زﻏﻠﻮل!“ = )4( ‪DynamicArray‬‬

‫)4( ‪Print DynamicArray‬‬          ‫ﺗﻄﺒﻊ "زﻏﻠﻮل!" ‘‬
‫)2( ‪Print DynamicArray‬‬          ‫ﺗﻄﺒﻊ "اﻟﻬﻨﻮف" ‘‬

‫اﻟﺤﺪﻳﺚ ﻋﻦ ‪ Preserve‬ﻳﻘـﻮدﻧﻲ ﻻﺧﺒـﺎرك اﻧـﻚ ﻟـﻦ ﺗﺴـﺘﻄﻴﻊ ﺗﻐﻴﻴـﺮ اﺑﻌـﺎد اﻟﻤﺼـﻔﻮﻓﺔ،‬
                                                  ‫ﻓﺎﻟﻤﺼﻔﻮﻓﺎت اﻟﺪﻳﻨﺎﻣﻴﻜﻴﺔ اﻟﺘﺎﻟﻴﺔ:‬

‫‪Dim OneDim () As Integer‬‬
‫‪Dim TwoDim () As Integer‬‬

‫)4( ‪ReDim OneDim‬‬
‫)2 ,2( ‪ReDim TwoDim‬‬

                                      ‫ﻟﻦ ﺗﺴﺘﻄﻴﻊ ﺗﻐﻴﻴﺮ اﺑﻌﺎدهﺎ ﺑﺎﺳﺘﺨﺪام ‪:Preserve‬‬
                                            ‫29‬


‫ﻣﺴﺘﺤﻴﻞ ‘‬
‫)3 ,3( ‪ReDim Preserve OneDim‬‬
‫)1( ‪ReDim Preserve TwoDim‬‬
‫وﻟﻜﻦ هﺬا ﻣﻤﻜﻦ ‘‬
‫)3 ,3( ‪ReDim OneDim‬‬
‫)1( ‪ReDim TwoDim‬‬

‫ﻣﻦ اﻟﻤﺰاﻳـﺎ اﻟﺘـﻲ اﺿـﻴﻔﺖ اﻟـﻰ اﻻﺻـﺪار 6‪ VB‬ﻟﻠﻤﺼـﻔﻮﻓﺎت اﻟﺪﻳﻨﺎﻣﻴﻜﻴـﺔ هـﻲ اﻣﻜﺎﻧﻴـﺔ‬
‫ﻧﺴﺦ ﻗﻴﻢ ﻣﺼﻔﻮﻓﺔ آﺎﻣﻠﺔ اﻟﻰ اﺧﺮى ﻓـﻲ ﺳـﻄﺮ واﺣـﺪ ﺷـﺮﻳﻄﺔ ان ﺗﻜﻮﻧـﺎ ﻣـﻦ ﻧﻔـﺲ‬
                                               ‫اﻟﻨﻮع، ﻓﺒﺎﻣﻜﺎﻧﻚ آﺘﺎﺑﺔ ﺷﻴﺌﺎ ﻣﺜﻞ:‬

‫‪Dim MyArray (20) As Integer‬‬
‫‪Dim YourArray () As Integer‬‬
‫01 = )0( ‪MyArray‬‬
‫02 = )1( ‪MyArray‬‬
‫…‬
‫)( ‪YourArray () = MyArray‬‬
‫01 = ‘ )0( ‪Print YourArray‬‬

‫ﻧﻘﻄﺔ اﺧﻴﺮة ﺣﻮل اﻟﻤﺼﻔﻮﻓﺎت اﻟﺪﻳﻨﺎﻣﻴﻜﺔ وهـﻲ اﻣﻜﺎﻧﻴـﺔ ﺗـﺪﻣﻴﺮهﺎ ﺑﺎﺳـﺘﺨﺪام اﻟﻌﺒـﺎرة‬
                                                                       ‫‪:Erase‬‬

‫‪Erase OneDim‬‬

                                                  ‫اﻟﻨﻮع ‪ Variant‬ﻣﺮة اﺧﺮى:‬
‫اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪ Variant‬ﻳﻤﻜـﻦ ﻟﻬـﺎ ان ﺗﻤﺜـﻞ ﻣﺼـﻔﻮﻓﺎت اﻣـﺎ ﻋـﻦ ﻃﺮﻳـﻖ اﺳـﻨﺎد‬
                                                                  ‫ﻣﺼﻔﻮﻓﺔ ﻟﻬﺎ:‬

‫‪Dim Cities(2) As String‬‬
‫‪Dim vCities As Variant‬‬

‫"اﻟﺮﻳﺎض" = )0(‪Cities‬‬
‫"ﺟﺪة" = )1(‪Cities‬‬
‫"اﺑﻬﺎ" = )2(‪Cities‬‬
‫‪vCities = Cities‬‬
‫)1(‪Print vCities‬‬       ‫ﺟﺪة ‘‬
                                             ‫39‬


                                                       ‫او ﺑﺎﺳﺘﺨﺪام اﻟﺪاﻟﺔ ‪:Array‬‬

‫‪Dim vCities As Variant‬‬

‫)"اﺑﻬﺎ" ," ﺟﺪة" ," اﻟﺮﻳﺎض"(‪vCities = Array‬‬
‫)0(‪Print vCities‬‬      ‫اﻟﺮﻳﺎض ‘‬

‫ﻣﻦ اﻻﺷﻴﺎء اﻟﺘﻲ ﺗﻌﺠﺒﻨﻲ ﻓـﻲ اﻟﻤﺘﻐﻴـﺮات ﻣـﻦ اﻟﻨـﻮع ‪ Variant‬هـﻮ اﻧﺸـﺎء ﻣﺼـﻔﻮﻓﺎت‬
‫ﻣﺨﺘﻠﻔﺔ اﻻﺑﻌﺎد ‪ ،Variable-Dimension Arrays‬وهﻲ ﻣﺼـﻔﻮﻓﺎت اﺑﻌﺎدهـﺎ ﺗﺨﺘﻠـﻒ ﻣـﻦ‬
‫ﻋﻨﺼﺮ ﻻﺧﺮ، ﻓﻘﺪ ﻳﻜﻮن اﻟﻌﻨﺼﺮ اﻻول اﺣﺎدي اﻟﺒﻌﺪ واﻟﺜﺎﻧﻲ ﺛﻨﺎﺋﻲ اﻟﺒﻌﺪ واﻟﺜﺎﻟـﺚ ﺛﻼﺛـﻲ‬
‫اﻟﺒﻌﺪ وﺗﻄﺒﻴﻘﻬﺎ ﺳﻬﻞ ﺟﺪا، اﻟﻄﺒﺨـﺔ آﻠﻬـﺎ اﺣﺘـﻮاء ﻣﺼـﻔﻮﻓﺔ ﻣـﻦ اﻟﻨـﻮع ‪ Variant‬ﻋﻠـﻰ‬
                                                                 ‫ﻋﺪة ﻣﺼﻔﻮﻓﺎت:‬

‫‪Dim VarDim(2) As Variant‬‬

‫"اﺣﺎدي اﻟﺒﻌﺪ" = )0(‪VarDim‬‬
‫)"ﺛﻨﺎﺋﻲ اﻟﺒﻌﺪ2" ,"ﺛﻨﺎﺋﻲ اﻟﺒﻌﺪ1"(‪VarDim(1) = Array‬‬
‫)"ﺛﻼﺛﻲ اﻟﺒﻌﺪ3" ,"ﺛﻼﺛﻲ اﻟﺒﻌﺪ2" ,"ﺛﻼﺛﻲ اﻟﺒﻌﺪ1"(‪VarDim(2) = Array‬‬

‫)0(‪Print VarDim‬‬
‫)1()1(‪Print VarDim(1)(0), VarDim‬‬
‫)2()2(‪Print VarDim(2)(0), VarDim(2)(1), VarDim‬‬


                                                                 ‫اﻟﻤﺠﻤﻮﻋﺎت‬
‫ﺗﻠﻌﺐ اﻟﻤﺼﻔﻮﻓﺎت دورا ﺣﻴﻮﻳﺎ ﻓﻲ ﺑﺮاﻣﺠﻚ اﻟﺠﺪﻳﺔ ﺧﺎﺻﺔ ﺑﺎﻻﻣﻮر اﻟﺘﻲ ﺗﺘﻌﻠﻖ ﺑﺎﻟﺤﻠﻘﺎت‬
‫اﻟﺘﻜﺮارﻳﺔ وﻏﻴﺮهﺎ. اﻻ ان اﻟﻤﺠﻤﻮﻋﺎت ‪ Collections‬ﺗﻌﺘﺒـﺮ اآﺜـﺮ ﻣﺮوﻧـﺔ ﻣـﻦ اﻟﻤﺼـﻔﻮﻓﺎت‬
‫ﻣﻦ ﺣﻴﺚ اﺿﺎﻓﺔ وازاﻟﺔ اﻟﻌﻨﺎﺻﺮ ﻣﻨﻬﺎ. اﻟﻬﺪف ﻣﻦ هﺬﻩ اﻟﻔﻘﺮة هﻮ ﺗﻌﺮﻳﻔﻚ ﺑﺎﻟﻤﺠﻤﻮﻋﺎت‬
                                                           ‫وﻃﺮق اﺳﺘﺨﺪاﻣﺎﺗﻬﺎ.‬

                                                               ‫ﻣﺰاﻳﺎ اﻟﻤﺠﻤﻮﻋﺎت:‬
‫اﻟﻤﺠﻤﻮﻋــﺎت ‪ Collections‬ﻋﺒــﺎرة ﻋــﻦ آﺎﺋﻨــﺎت ﻣﺸــﺘﻘﺔ ﻣــﻦ ﻣﻜﺘﺒــﺔ ‪ ،VBA‬وﻇﻴﻔﺘﻬــﺎ‬
      ‫اﻟﺮﺋﻴﺴﻴﺔ ﻣﺜﻞ وﻇﻴﻔﺔ اﻟﻤﺼﻔﻮﻓﺎت ﺗﻤﺎﻣﺎ اﻟﻰ اﻧﻬﺎ ﺗﺨﺘﻠﻒ ﻋﻨﻬﺎ ﻓﻲ اﻟﻨﻘﺎط اﻟﺘﺎﻟﻴﺔ:‬
                                               ‫49‬


     ‫ـ‬                                ‫ـ‬
‫- اﻟﻤﺠﻤﻮﻋـﺎت ﻻ ﺗﺤﺘـﺎج اﻟـﻰ ﺗﺤﺪﻳـﺪ ﺣﺠﻤﻬـﺎ ﻋﻨـﺪ ﻋﻤﻠﻴـﺔ ﺗﺼـﺮﻳﺤﻬﺎ. ﻓﻌﻨـﺪ ﺗﺼـﺮﻳﺤﻚ‬
‫ﻟﻤﺠﻤﻮﻋﺔ ﺟﺪﻳﺪةـ ﺗﺴﺘﻄﻴﻊ اﺿﺎﻓﺔ اﻟﻌﻨﺎﺻﺮ ﻟﻬﺎ وﻗﺖ اﻟﺘﻨﻔﻴﺬ دﻳﻨﺎﻣﻴﻜﻴﺎ أي ﺑﺪون ﺗﺤﺪﻳـﺪ‬
                                                          ‫أي ﺣﺠﻢ ﻟﻬﺎ ﺳﺘﺎﺗﻴﻜﻴﺎ.‬

‫- ﺗﺴﺘﻄﻴﻊ اﺿﺎﻓﺔ اﻟﻌﻨﺎﺻﺮ اﻟﻰ اﻟﻤﺠﻤﻮﻋﺎت ﻓﻲ أي ﻣﻜﺎن ﺗﺮﻳـﺪﻩ ﻓـﻲ اﻟﻤﺠﻤﻮﻋـﺔ. أي‬
‫ﻟﺴﺖ ﻣﻀﻄﺮا ﻟﻮﺿﻌﻬﺎ ﻓﻲ ﻧﻬﺎﻳﺔ اﻟﻘﺎﺋﻤﺔ ﻣﺜﻞ اﻟﻤﺼﻔﻮﻓﺎت، ﻓﺎﻟﻤﺠﻤﻮﻋﺎت ﺗﻌﻄﻴﻚ ﺣﺮﻳﺔ‬
‫آﺒﻴﺮة ﻓﻲ اﺿﺎﻓﺔ وﺣﺬف اﻟﻌﻨﺎﺻﺮ ﺳﻮاء آﺎﻧﺖ ﻓﻲ ﺑﺪاﻳﺔ اﻟﻤﺠﻤﻮﻋﺔ او ﻧﻬﺎﻳﺘﻬـﺎ او ﺣﺘـﻰ‬
                                                                ‫ﻓﻲ وﺳﻄﻬﺎ.‬

‫- اﻟﻤﺠﻤﻮﻋﺔ اﻟﻮاﺣﺪة ﻳﻤﻜﻦ ان ﺗﺤﺘﻮي ﻋﻨﺎﺻﺮهﺎ ﻋﻠـﻰ اﻧـﻮاع ﺑﻴﺎﻧـﺎت ﻣﺨﺘﻠﻔـﺔ، أي ﻗـﺪ‬
‫ﻳﻜﻮن اﻟﻌﻨﺼﺮ اﻻول ﻓﻴﻬﺎ ‪ String‬واﻟﺜﺎﻧﻲ ‪ Integer‬ﺑﻌﻜـﺲ اﻟﻤﺼـﻔﻮﻓﺎت اﻟﺘـﻲ ﻻﺑـﺪ ﻣـﻦ‬
                                                          ‫ﺗﻮﺣﻴﺪ ﻧﻮع ﻋﻨﺎﺻﺮهﺎ.‬

               ‫ـ‬     ‫ـ‬      ‫ـ‬
‫- ﺗ ـﻮﻓﺮ اﻟﻤﺠﻤﻮﻋ ـﺎت ﻃ ـﺮق اﺧ ـﺮى ﻟﺘﺤﺪﻳــﺪ ﻋﻨﺎﺻ ـﺮهﺎ ﻋ ـﻦ ﻃﺮﻳ ـﻖ ﻣﻔ ـﺎﺗﻴﺢ ‪ Key‬ﺑــﺪون‬
                                   ‫ـ‬                 ‫ـ‬      ‫ـ‬     ‫ـ‬            ‫ـ‬
                                  ‫اﺳﺘﺨﺪام اﺳﻠﻮب اﻟﺘﺮﻗﻴﻢ اﻟﺬي ﺗﺘﺒﻌﻪ اﻟﻤﺼﻔﻮﻓﺎت.‬

‫ﺑﻌﺪ هﺬﻩ اﻟﻤﺰاﻳﺎ ﻗﺪ ﺗﺤﺮم اﺳﺘﺨﺪام اﻟﻤﺼﻔﻮﻓﺎت وﺗﻨﺘﻘﻞ اﻟـﻰ اﻟﻤﺠﻤﻮﻋـﺎت اﻟـﻰ اﻻﺑـﺪ!‬
‫ﻟﻜﻦ ﻣﻦ اﻟﻤﻬﻢ ﺟﺪا ان ﺗﻀﻊ ﻓﻲ ذهﻨﻚ ان اﻟﻤﺠﻤﻮﻋﺎت اﺑﻄﺄ ﻣﻦ اﻟﻤﺼﻔﻮﻓﺎت ﺑﺎآﺜﺮ ﻣﻦ‬
‫001 ﻣﺮة! ﻟﺬﻟﻚ، ﻻ ﺗﺴﺘﺨﺪﻣﻬﺎ ان آﺎﻧـﺖ اﻟﺴـﺮﻋﺔ ﺗﻌﻨـﻲ ﻟـﻚ اﻟﺸـﺊ اﻟﻜﺜﻴـﺮ. اﻟﻤﺰﻳـﺪ‬
‫اﻳﻀﺎ، اﻟﻤﺠﻤﻮﻋﺎت ﺗﺴﺘﻬﻠﻚ ﻣﺴﺎﺣﺔ اآﺒﺮ ﺑﻜﺜﻴﺮ ﻣﻦ اﻟﻤﺴﺎﺣﺔ اﻟﻤﻄﻠﻮﺑﺔ ﻓـﻲ اﻟـﺬاآﺮة،‬
‫وﻳﻌﻴﺐ اﻟﻤﺠﻤﻮﻋﺎت ان ﻋﻨﺎﺻﺮهﺎ اﻟﻤﻀﺎﻓﺔ ﻗﺎﺑﻠﺔ ﻟﻠﻘـﺮاءة ﻟﻜـﻦ ﻟﻴﺴـﺖ ﻗﺎﺑﻠـﺔ ﻟﻠﺘﻌـﺪﻳﻞ!‬
‫ﻓﻠﺘﻌﺪﻳﻞ ﻗﻴﻤﺔ ﻋﻨﺼﺮ ﻣﻦ ﻋﻨﺎﺻﺮ اﻟﻤﺠﻤﻮﻋﺔ، ﻋﻠﻴﻚ اﻟﻘﻴﺎم ﺑﺎﺳﻠﻮب ﻏﻴﺮ ﻣﺒﺎﺷﺮ آﺤـﺬف‬
                              ‫اﻟﻌﻨﺼﺮ اﻟﻤﺮاد ﺗﻌﺪﻳﻠﻪ واﺿﺎﻓﺘﻪ ﻣﻦ ﺟﺪﻳﺪ ﺑﻌﺪ اﻟﺘﻌﺪﻳﻞ.‬

                                                     ‫ﺑﺮﻣﺠﺔ اﻟﻤﺠﻤﻮﻋﺎت:‬
‫اﻟﺨﻄﻮة اﻻوﻟﻰ اﻟﺘﻲ ﺗﺤﺘﺎﺟﻬﺎ هﻲ اﻧﺸﺎء آﺎﺋﻦ اﻟﻤﺠﻤﻮﻋـﺔ واﻟـﺬي ﺗﺤﺼـﻞ ﻋﻠﻴـﻪ ﻣـﻦ‬
                                                  ‫اﻟﻨﻮع -اﻟﻔﺌﺔ- ‪:Collection‬‬

‫‪Dim MyCol As New Collection‬‬

‫وﻻﺿﺎﻓﺔ ﻋﻨﺎﺻﺮ اﻟﻰ اﻟﻤﺠﻤﻮﻋﺔ، اﺳﺘﺨﺪم اﻟﻄﺮﻳﻘﺔ ‪ Add‬ﻣﻊ ارﺳﺎل ﻗﻴﻤﺔ اﻟﻌﻨﺼـﺮ ﻟﻬـﺎ.‬
‫آﺬﻟﻚ، ﺗﺴﺘﻄﻴﻊ ارﺳﺎل ﻣﻔﺘﺎح ‪ Key‬اذا اردت ﺣﺘﻰ ﺗﺴﺘﺨﺪم آﻄﺮﻳﻘـﺔ اﺧـﺮى ﻟﻠﻮﺻـﻮل‬
                                          ‫اﻟﻰ اﻟﻌﻨﺼﺮ ﺑﺪون اﻻﻋﺘﻤﺎد ﻋﻠﻰ رﻗﻤﻪ:‬
                                              95


MyCol.Add "amazon.com", "shopping"
MyCol.Add "hotmail.com", "mail"
MyCol.Add "yahoo.com", "Search"

-‫ -او ﺣﺘـﻰ ﺗﺠـﺎهﻼ‬Item ‫ﺗﺴﺘﻄﻴﻊ اﻟﻮﺻﻮل اﻟﻰ ﻋﻨﺎﺻﺮ اﻟﻤﺠﻤﻮﻋﺔ ﻋﻦ ﻃﺮﻳﻖ اﻟﻄﺮﻳﻘـﺔ‬
                                             :‫وارﺳﺎل رﻗﻢ اﻟﻌﻨﺼﺮ او ﻣﻔﺘﺎﺣﻪ‬

Print MyCol.Item(1) ' amazon.com
Print MyCol.Item("mail") ' hotmail.com
Print MyCol("Search") ' yahoo.com

                                         :Remove ‫وﻟﺤﺬف اﻟﻌﻨﺼﺮ اﺳﺘﺨﺪم اﻟﻄﺮﻳﻘﺔ‬

MyCol.Remove 1
MyCol.Remove "mail"

          :‫واﺳﺮع ﻃﺮﻳﻘﺔ ﺗﻤﻜﻨﻚ ﻣﻦ ﺣﺬف ﺟﻤﻴﻊ اﻟﻌﻨﺎﺻﺮ، ﻗﻢ ﺑﺎﻧﻬﺎء آﺎﺋﻦ اﻟﻤﺠﻤﻮﻋﺔ‬

Set MyCol = Nothing

        :‫ﻟﻜﻦ ﺗﺬآﺮ! ﻋﻠﻴﻚ ﺑﺎﻋﺎدة اﻧﺸﺎء اﻟﻜﺎﺋﻦ ﺣﺘﻰ ﺗﺘﻤﻜﻦ ﻣﻦ اﺿﺎﻓﺔ ﻋﻨﺎﺻﺮ ﺟﺪﻳﺪة‬

‘ ‫ﺧﻄﺄ ﻓﻲ هﺬا اﻟﺴﻄﺮ‬
MyCol.Add "amazon.com", "shopping"

‘ ‫ﻻﺑﺪ ﻣﻦ اﻧﺸﺎء اﻟﻜﺎﺋﻦ ﻣﻦ ﺟﺪﻳﺪ‬
Set MyCol = New Collection
MyCol.Add "amazon.com", " shopping"

               :Count ‫اﺧﻴﺮا، ﻟﻤﻌﺮﻓﺔ ﻋﺪد اﻟﻌﻨﺎﺻﺮ ﻓﻲ اﻟﻤﺠﻤﻮﻋﺔ اﺳﺘﺨﺪم اﻟﻄﺮﻳﻘﺔ‬

Print MyCol.Count
                                              ‫69‬


                                                               ‫اﻻﺟﺮاءات واﻟﺪوال‬
                                ‫ـ‬     ‫ـ‬      ‫ـ‬                  ‫ـ‬      ‫ـ‬     ‫ـ‬
‫ﻳﻤﻜﻨ ـﻚ ﺣﺒﻴ ـﺐ اﻟﻘﻠ ـﺐ ‪ Visual Basic‬ﻣ ـﻦ ﺗﻌﺮﻳ ـﻒ اﺟ ـﺮاءات ‪ Sub’s‬ودوال ‪،Functions‬‬
‫ﺣﻴﺚ ﻳﻤﻜﻦ ﻟﻠﺪوال ﻣﻦ اﻟﻌﻮدة ﺑﻘﻴﻤﺔ ﺑﻌﺪ ﻧﻬﺎﻳﺔ ﺗﻨﻔﻴﺬ اﻟﺪاﻟﺔ، ﻧـﻮع اﻟﻘﻴﻤـﺔ اﻟﺘـﻲ ﺗﻌـﻮد‬
                             ‫ﺑﻬﺎ اﻟﺪاﻟﺔ هﻮ اﻟﻨﻮع اﻟﺬي ﺗﻜﺘﺒﺘﻪ ﻓﻲ ﻧﻬﺎﻳﺔ ﺗﻌﺮﻳﻒ اﻟﺪاﻟﺔ:‬

‫داﻟﺔ ﺗﻌﻮد ﺑﻘﻴﻤﺔ ﺣﺮﻓﻴﺔ ‘‬
‫‪Function GetUserName () As String‬‬
        ‫”ﺗﺮآﻲ اﻟﻌﺴﻴﺮي“ = ‪GetUserName‬‬
‫‪End Sub‬‬

‫داﻟﺔ ﺗﻌﻮد ﺑﺘﺮآﻴﺐ ‪‘ UDT‬‬
‫‪Function GetPersonData () As typPerson‬‬
       ‫”ﺗﺮآﻲ اﻟﻌﺴﻴﺮي“ = ‪GetPersonData.sName‬‬
       ‫99 = ‪GetPersonData.iAge‬‬
‫‪End Function‬‬

   ‫اﻟﻜﻮد اﻟﻤﻮﺟﻮد داﺧﻞ اﻟﺪاﻟﺔ، ﻳﺘﻌﺎﻣﻞ ﻣﻊ اﺳﻢ اﻟﺪاﻟﺔ آﻤﺘﻐﻴﺮ ﻣﻦ ﻧﻔﺲ ﻧﻮع اﻟﺪاﻟﺔ:‬

‫‪Function OddNumbers() As String‬‬
  ‫‪Dim iCounter As Integer‬‬

  ‫”“ = ‪OddNumbers‬‬
  ‫9 ‪For iCounter = 0 To‬‬
     ‫‪If iCounter Mod 2 <> 0 Then‬‬
         ‫‪OddNumbers = OddNumbers & iCounter‬‬
     ‫‪End If‬‬
  ‫‪Next‬‬
‫‪End Function‬‬

‫ﺗﻨﺘﻬﻲ ﻋﻤﻠﻴـﺔ ﺗﻨﻔﻴـﺬ اﻻﺟـﺮاء او اﻟﺪاﻟـﺔ ﺑﻤﺠـﺮد اﻟﻮﺻـﻮل اﻟـﻰ ﻧﻬﺎﻳﺘـﻪ، ﺗﺴـﺘﻄﻴﻊ اﻧﻬـﺎء‬
‫ﺗﻨﻔﻴﺬهﻤﺎ ﻗﺒﻞ ذﻟـﻚ ﺑﺎﺳـﺘﺨﺪام اﻟﻌﺒـﺎرة ‪ Exit Sub‬ﻟﻼﺟـﺮاءات واﻟﻌﺒـﺎرة ‪Exit Function‬‬
‫ﻟﻠﺪوال، هﺬا ﻣﺜﺎل ﻟﻠﺨﻮارزﻣﻴﺎت اﻟﺘﺮاﺟﻌﻴﺔ ‪ Recursion‬ﻳﺴﺘﺨﺪم ‪ Exit Function‬ﻻﻧﻬـﺎء‬
                                                                ‫ﻋﻤﻠﻴﺔ ﺗﻨﻔﻴﺬ اﻟﺪاﻟﺔ:‬
                                                  ‫79‬


‫‪Function Factorial(iNum As Integer) As Long‬‬
  ‫‪If iNum = 1 Then‬‬
      ‫1 = ‪Factorial‬‬
      ‫‪Exit Function‬‬
  ‫‪Else‬‬
      ‫)1 - ‪Factorial = iNum * Factorial(iNum‬‬
  ‫‪End If‬‬
‫‪End Function‬‬

‫ﺑﺎﻟﻨﺴـــﺒﺔ ﻟﻘﺎﺑﻠﻴـــﺔ اﻟﺮؤﻳـــﺔ ﻟﻼﺟـــﺮاءات واﻟـــﺪوال ﻓﺎﻻﻓﺘﺮاﺿـــﻴﺔ ‪ ،Public‬أي ﺗﺴـــﺘﻄﻴﻊ‬
                                             ‫اﺳﺘﺪﻋﺎﺋﻬﺎ ﻣﻦ أي ﻣﻜﺎن ﻓﻲ اﻟﻤﺸﺮوع:‬

‫ﻓﻲ ﻣﻠﻒ ﺑﺮﻣﺠﺔ ‪‘ BAS‬‬
‫)( 1‪Sub MySub‬‬
       ‫…‬
‫‪End Sub‬‬

‫ﻓﻲ ﻧﺎﻓﺬة ﻧﻤﻮذج 1‪‘ Form‬‬
‫)( 2‪Public Sub MySub‬‬            ‫ﻳﻤﻜﻨﻚ ﺗﺠﺎهﻞ اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪‘ Public‬‬
        ‫…‬
‫‪End Sub‬‬

‫ﻓﻲ ﻧﺎﻓﺬة اﻟﻨﻤﻮذج 2‪‘ Form‬‬
‫)(‪Private Sub Form_Load‬‬
        ‫1‪MySub‬‬
        ‫2‪Form1.MySub‬‬
‫‪End Sub‬‬

‫اﻣﺎ اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ Private‬اﻟﺴﺎﺑﻘﺔ ﻻﺳﻢ اﻻﺟﺮاء او اﻟﺪاﻟـﺔ، ﻓﻬـﻲ ﺗﻤﻨـﻊ اﻟﻤﺒـﺮﻣﺞ‬
                                    ‫ﻣﻦ اﺳﺘﺪﻋﺎء اﻻﺟﺮاء ﻣﻦ ﺧﺎرج اﻟﻮﺣﺪة اﻟﺒﺮﻣﺠﻴﺔ:‬

‫ﻓﻲ ﻧﺎﻓﺬة ﻧﻤﻮذج 1‪‘ Form‬‬
‫)( ‪Private Sub MySub‬‬
        ‫…‬
‫‪End Sub‬‬
                                               ‫89‬


‫ﻓﻲ ﻧﺎﻓﺬة اﻟﻨﻤﻮذج 2‪‘ Form‬‬
‫)(‪Private Sub Form_Load‬‬
        ‫‪Form1.MySub‬‬           ‫ﻟﻦ ﺗﺴﺘﻄﻴﻊ اﺳﺘﺪﻋﺎء اﻻﺟﺮاء ﻻﻧﻪ ﺧﺎص ﺑﺎﻟﻨﻤﻮذج 1‪ Form‬ﻓﻘﻂ ‘‬
‫‪End Sub‬‬

‫اﻣﺎ ﺗـﺄﺛﻴﺮ اﻟﻜﻠﻤـﺔ اﻟﻤﺤﺠـﻮزة ‪ Friend‬ﻓﻬـﻮ ﻧﻔـﺲ ﺗـﺄﺛﻴﺮ اﻟﻜﻠﻤـﺔ اﻟﻤﺤﺠـﻮزة ‪ Public‬ﻓـﻲ‬
‫اﻟﻤﺸﺎرﻳﻊ اﻟﻘﻴﺎﺳﻴﺔ ‪ ،Standard EXE‬وﻳﻜﻤﻦ اﻟﻔﺮق ﺑﻴﻨﻬﻤﺎ ﻓـﻲ ﺣـﺎﻻت ﺑﻨـﺎء ﻣﺸـﺎرﻳﻊ‬
‫ﻣﻦ اﻟﻨﻮع ‪ ActiveX‬ﺣﻴﺚ ان اﻻﺟﺮاءات ﻣﻦ اﻟﻨﻮع ‪ Public‬ﻳﻤﻜﻦ ان ﻳﺴﺘﺪﻋﻴﻬﺎ اﻟﻤﺒـﺮﻣﺞ‬
‫ﻣﻦ ﺧﺎرج اﻟﻤﺸﺮوع ﻋﻦ ﻃﺮﻳﻖ اﻻﺗﺼﺎل ‪ ،COM‬اﻣـﺎ اﻻﺟـﺮاءات ﻣـﻦ اﻟﻨـﻮع ‪ Friend‬ﻓﻠـﻦ‬
            ‫ﻳﺘﻤﻜﻦ أي ﺷﺨﺺ ﻣﻦ اﺳﺘﺪﻋﺎﺋﻬﺎ ﻣﺎ داﻣﺖ اآﻮادﻩ ﺧﺎرج اآﻮاد ﻣﺸﺮوﻋﻚ.‬

                                              ‫اﻻرﺳﺎل ﺑﺎﻟﻤﺮﺟﻊ او اﻟﻘﻴﻤﺔ‬
‫اﻻﺟـــﺮاءات ‪ Sub's‬او ‪ Functions‬ﻗﺎﺑﻠـــﺔ ﻻﺳـــﺘﻘﺒﺎل ﻣﺘﻐﻴـــﺮات ‪ .Parameters‬ﺗﺤﺪﻳـــﺪ‬
‫اﻟﻤﺘﻐﻴﺮات اﻟﺘﻲ ﻳﺤﺘﺎﺟﻬﺎ اﻻﺟﺮاء ﻳﻌﺘﻤﺪ ﺑﺸﻜﻞ آﺒﻴﺮ ﻋﻠﻰ اﻟﻬﺪف واﻟﻮﻇﻴﻔﺔ اﻟﺘﻲ ﻳﻘﻮم‬
‫ﺑﻬــﺎ اﻻﺟــﺮاء. ﺑﺼــﻔﺔ ﻋﺎﻣــﺔ، اﻻﺟــﺮاءات ﺳــﻮاء آﺎﻧــﺖ ‪ Sub’s‬او ‪ Functions‬ﻳﻤﻜــﻦ ان‬
‫ﺗﺴﺘﻘﺒﻞ اﻧﻮاع ﻣﺨﺘﻠﻔﺔ ﻣﻦ اﻟﻤﺘﻐﻴﺮات ﺳﻮاء آﺎﻧﺖ اﻧﻮاع ﻗﻴﺎﺳﻴﺔ آـ ‪ Integer‬او ‪String‬‬
‫.... اﻟﺦ، او ﺣﺘﻰ اﻧﻮاع ﻣﻌﺮﻓﺔ ﻣﻦ ﻗﺒﻞ اﻟﻤﺴﺘﺨﺪم آﺘﺮآﻴﺒـﺎت ‪ UDT‬او ﻓﺌـﺎت ‪.Classes‬‬
‫ﺑﺎﻻﺿﺎﻓﺔ اﻟﻰ ﻗﺎﺑﻠﻴﺔ اﻻﺟﺮاءات ﻻﺳﺘﻘﺒﺎل اﻟﻤﺼﻔﻮﻓﺎت ‪ .Arrays‬ﻋﻤﻠﻴﺔ ارﺳـﺎل اﻟﻤﺘﻐﻴـﺮ‬
‫اﻟﻰ اﻻﺟﺮاء ﺗﺘﻄﻠﺐ وﺿﻊ اﻟﻘﻴﻢ ﺑﻴﻦ ﻗﻮﺳـﻴﻦ ﻓـﻲ ﺣﺎﻟـﺔ آـﻮن اﻻﺟـﺮاء ﺳـﻴﻌﻮد ﺑﻘﻴﻤـﺔ‬
                    ‫ﻟﻤﺴﺘﺪﻋﻲ ذﻟﻚ اﻻﺟﺮاء، اﻣﺎ ﻏﻴﺮ ذﻟﻚ ﻓﻼ ﻳﺸﺘﺮط وﺿﻊ اﻻﻗﻮاس.‬
‫اﻓﺘﺮاﺿﻴﺎ، ﺗﺴﺘﻘﺒﻞ اﻻﺟﺮاءات اﻟﻤﺘﻐﻴﺮات اﻟﻤﺮﺳﻠﺔ ﻟﻬﺎ ﺑﺎﻟﻤﺮﺟﻊ. وان رﻏﺒﺖ ﻓﻲ ﺟﻌﻠﻬـﺎ‬
‫ﺗﺴﺘﻘﺒﻞ اﻟﻤﺘﻐﻴﺮات ﺑﺎﻟﻘﻴﻤﺔ ﻓﻼﺑﺪ ﻣﻦ آﺘﺎﺑﺔ اﻟﻜﻠﻤﺔ ‪ ByVal‬ﻋﻨﺪ ﺗﺼـﺮﻳﺢ اﻟﻤﺘﻐﻴـﺮ اﻟـﺬي‬
‫ﻳﺴﺘﻘﺒﻠﻪ اﻻﺟﺮاء. اﻣﺎ اﻟﻔﺮق ﺑﻴﻦ ﻋﻤﻠﻴﺔ ارﺳﺎل اﻟﻤﺘﻐﻴﺮ ﺑﺎﻟﻤﺮﺟﻊ وارﺳﺎﻟﻪ ﺑﺎﻟﻘﻴﻤﺔ ﻓﻬﻮ‬
‫ﺑﺴﻴﻂ ﺟﺪا. ﻓﻌﻤﻠﻴﺔ ارﺳﺎل اﻟﻤﺘﻐﻴﺮ ﺑﺎﻟﻤﺮﺟﻊ ‪ Reference‬ﺗﻘـﻮم ﻋﻠـﻰ اﺳـﺎس ارﺳـﺎل‬
‫ﻣﺆﺷﺮ ﻟﻠﻤﺘﻐﻴﺮ أي ﻋﻨﻮان اﻟﻤﺘﻐﻴﺮ ﺑﺎﻟﺬاآﺮة واﻟﺬي ﻋـﻦ ﻃﺮﻳﻘـﻪ ﺗﺴـﺘﻄﻴﻊ ﺗﻌـﺪﻳﻞ ﻗﻴﻤـﺔ‬
                                                               ‫اﻟﻤﺘﻐﻴﺮ ﻣﻦ اﻻﺟﺮاء:‬

‫)(‪Sub Start‬‬
‫هﻨﺎ ﻧﻘﻄﺔ اﻟﺒﺪاﻳﺔ ‘‬
   ‫‪Dim X As Integer‬‬

‫0=‪' X‬‬
 ‫‪Print X‬‬
 ‫‪MySub X‬‬
‫5=‪' X‬‬
                                            ‫99‬


  ‫‪Print X‬‬
‫‪End Sub‬‬

‫)‪Sub MySub (X As Integer‬‬
  ‫5=‪X‬‬
‫‪End Sub‬‬

‫ﻓﻜﻤﺎ ﺗﻼﺣﻆ ﻓﻲ اﻟﻜﻮد اﻟﺴﺎﺑﻖ، اﻻﺟﺮاء ‪ MySub‬ﺗﻮﻗﻊ اﺳﺘﻘﺒﺎل ﻣﺮﺟﻊ ﻟﻤﺘﻐﻴﺮ ﻣﻦ ﻧـﻮع‬
‫‪ Integer‬ﻣﻤﺎ ﻳﻌﻄﻴﻪ اﻟﻘﺪرة ﻋﻠﻰ ﺗﻐﻴﻴﺮ اﻟﻘﻴﻤﺔ اﻟﻤﺮﺳﻠﺔ ﻟﻪ. اﻟﻜﺜﻴﺮ ﻣﻦ اﻟﺤﻠﻮل ﻳﻮﻓﺮهـﺎ‬
‫ﻟﻚ اﺳﻠﻮب اﻻﺳﺘﺪﻋﺎء ﺑﺎﻟﻤﺮﺟﻊ ﻟﻌﻞ اﺳﻬﻠﻬﺎ اﺟﺮاء ﻳﻘﻮم ﺑﺘﺒﺪﻳﻞ ﻗﻴﻤﺘﻴﻦ ﻣﺮﺳﻠﺘﻴﻦ ﻟﻪ:‬

‫)‪Sub Swap (X As Variant, Y As Variant‬‬
‫اﺟﺮاء ﻳﺴﺘﺒﺪل ﻗﻴﻢ اﻧﻮاع ﻣﺨﺘﻠﻔﺔ ‘‬
‫ﻣﻦ اﻟﻤﺘﻐﻴﺮات اﻟﻤﺮﺳﻠﺔ ‘‬
   ‫‪Dim vTemp As Variant‬‬
   ‫‪vTemp = X : X = Y : Y = vTemp‬‬
‫‪End Sub‬‬

‫اﻣﺎ اﻻرﺳـﺎل ﺑﺎﻟﻘﻴﻤـﺔ ﻓﻬـﻮ اﺑﻄـﺄ ﻣـﻦ اﻻرﺳـﺎل ﺑـﺎﻟﻤﺮﺟﻊ ﺧﺎﺻـﺔ ﻣـﻊ اﻟﺤـﺮوف ‪Strings‬‬
‫واﻟﺴﺒﺐ ﻓﻲ ذﻟﻚ ان ‪ Visual Basic‬ﺳﻴﻀﻄﺮ ﻟﻨﺴﺦ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴـﺮ اﻟـﻰ ﻣﻜـﺎن ﻣﺆﻗـﺖ‬
‫ﻓﻲ اﻟﺬاآﺮة، آﺬﻟﻚ ﻟـﻦ ﺗﺴـﺘﻄﻴﻊ ﺗﻌـﺪﻳﻞ ﻗﻴﻤـﺔ اﻟﻤﺘﻐﻴـﺮ اﻟﻤﺮﺳـﻞ ﻟـﻚ. ﻟﺠﻌـﻞ اﻻﺟـﺮاء‬
                      ‫ﻳﺴﺘﻘﺒﻞ ﻣﺘﻐﻴﺮات ﺑﺎﻟﻘﻴﻤﺔ اﺳﺘﺨﺪم اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪:ByVal‬‬

‫)(‪Sub Start‬‬
‫هﻨﺎ ﻧﻘﻄﺔ اﻟﺒﺪاﻳﺔ ‘‬
   ‫‪Dim X As Integer, Y As Integer‬‬

 ‫0 = ‪' X = 0, Y‬‬
  ‫‪Print X, Y‬‬
  ‫‪MySub X, Y‬‬
 ‫0 = ‪' X = 3, Y‬‬
  ‫‪Print X, Y‬‬
‫‪End Sub‬‬

‫)‪Sub MySub (X As Integer, ByVal Y As Integer‬‬
  ‫5=‪X‬‬
                                               ‫001‬


  ‫01 = ‪Y‬‬
‫‪End Sub‬‬


                                                          ‫ارﺳﺎل اﻧﻮاع اﺧﺮى‬
‫ﺟﻤﻴــﻊ اﻻﻧــﻮاع اﻟﻘﻴﺎﺳــﻴﺔ ﻟﻠﻤﺘﻐﻴــﺮات ‪ .... Double ،Integer ،String‬اﻟــﺦ ﻳﻤﻜــﻦ ان‬
‫ﺗﺮﺳﻠﻬﺎ وﺗﺴﺘﻘﺒﻠﻬﺎ اﻻﺟﺮاءات، اﻣﺎ اﻻﻧﻮاع اﻻﺧﺮى آﺎﻻدوات ‪ ،Controls‬آﺎﺋﻨﺎت ﻣﻜﺘﺒـﺎت‬
       ‫ـ‬       ‫ـ‬             ‫ـ‬         ‫ـ‬                              ‫ـ‬
‫‪ VB‬و ‪ VBA‬آ ــ ‪ .... Screen ،Printer ،App‬اﻟ ـﺦ واﻟﺘﺮآﻴﺒ ـﺎت ‪ UDT‬ﻓﺘﺤﺘ ـﺎج ﻟﺸ ـﺊ ﻣــﻦ‬
                                                                           ‫اﻟﺘﻔﺼﻴﻞ:‬

                                                 ‫ارﺳﺎل ﻣﺘﻐﻴﺮات اﻟﻜﺎﺋﻨﺎت:‬
‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﺸﺎرﻳﻊ اﻟﻘﻴﺎﺳﻴﺔ ‪ Standard EXE‬ﻓﻴﻤﻜﻨﻚ ارﺳﺎل ﻣﺘﻐﻴﺮات ﺗﺎﺑﻌﺔ ﻟﻜﺎﺋﻨـﺎت‬
‫اﻟﻠﻐﺔ اﻟﻰ اﻻﺟﺮاءات دون أي ﻣﺸﺎآﻞ، اﻣـﺎ ﺑﺎﻟﻨﺴـﺒﺔ ﻟﻠﻤﺸـﺎرﻳﻊ اﻻﺧـﺮى آــ ‪ActiveX‬‬
‫‪ .... ActiveX OCX ،EXE‬اﻟﺦ ﻓﻼ ﻳﻤﻜﻨﻚ ﻋﻤـﻞ ذﻟـﻚ اﻻ ﻟﻼﺟـﺮاءت اﻟﺘﺎﺑﻌـﺔ ﻟﻤﺸـﺮوﻋﻚ‬
‫وهﻲ اﻻﺟﺮاءات اﻟﺘﻲ ﺗﺼﺮح ﺑﺎﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ Private‬او ‪ ،Friend‬واﻟﺴﺒﺐ ﻓﻲ ذﻟﻚ‬
‫ﻳﺒﺪو ﺑﺪﻳﻬﻴﺎ اذا ﻋﻠﻤﺖ ان اﻻﺟﺮاءات ﻣﻦ اﻟﻨﻮع ‪ Public‬ﻳﻤﻜـﻦ ان ﺗﺴـﺘﺪﻋﻰ ﻣـﻦ ﺑـﺮاﻣﺞ‬
‫اﺧﺮى ﻋﻦ ﻃﺮﻳﻖ ‪ COM‬آﻤﺎ ﺳﺘﻌﺮف ﻓﻲ اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ ﻋﺸﺮ "ﺑﺮﻣﺠﺔ اﻟﻤﻜﻮﻧﺎت ‪COM‬‬
                                                                         ‫1".‬

                                      ‫ارﺳﺎل اﻟﻤﺘﻐﻴﺮات اﻟﺘﺮآﻴﺒﺎت ‪:UDT‬‬
‫اﻟﻤﺘﻐﻴﺮات ﻣﻦ ﻧﻮع اﻟﺘﺮآﻴﺒﺎت ‪ UDT‬واﻟﺘﻲ ﺗﻨﺸﺌﻬﺎ ﻋﻦ ﻃﺮﻳﻖ اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠـﻮزة ‪Type‬‬
  ‫ﺗﺴﺘﻄﻴﻊ ارﺳﺎﻟﻬﺎ ﻟﻜﻦ ﻓﻲ ﺣﺎﻻت ﺧﺎﺻﺔ وﺷﺮوط ﻣﻌﻴﻨﺔ اﺧﺘﺼﺮهﺎ ﻓﻲ هﺬﻩ اﻟﻨﻘﺎط:‬

‫- اذا آﺎن ﻣﺠﺎل اﻟﺘﺮآﻴﺐ ﻣﻦ ﻧﻮع ‪ Private‬وﻣﻌـﺮف ﻓـﻲ داﺧـﻞ وﺣـﺪة ﺑﺮﻣﺠﻴـﺔ آﻨﺎﻓـﺬة‬
‫ﻧﻤﻮذج، ﻓﺌﺔ، ﻣﻠﻒ ﺑﺮﻣﺠﺔ اﻟﺦ.. ﻓﺎن اﻻﺟﺮاءت اﻟﺘﻲ داﺧﻞ ﺗﻠﻚ اﻟﻮﺣﺪة اﻟﺒﺮﻣﺠﻴﺔ ﻳﻤﻜـﻦ‬
                                ‫ﻟﻬﺎ ان ﺗﺴﺘﻘﺒﻞ اﻟﻤﺘﻐﻴﺮات ﻣﻦ ﻧﻮع ذﻟﻚ اﻟﺘﺮآﻴﺐ.‬

‫- اذا آــﺎن اﻟﺘﺮآﻴــﺐ ﻣﺠﺎﻟــﻪ ﻋــﺎم ‪ Public‬ﻣﻌــﺮف ﻓــﻲ ﻣﻠــﻒ ﺑﺮﻣﺠــﺔ ‪ BAS‬ﻓــﺎن ﺟﻤﻴــﻊ‬
‫اﻻﺟﺮاءات اﻟﺘﻲ ﻓﻲ ﻧﻔﺲ اﻟﻤﺸﺮوع ﻗﺎﺑﻠﺔ ﻻﺳﺘﻘﺒﺎل ذﻟﻚ اﻟﺘﺮآﻴﺐ ﺷﺮﻳﻄﺔ ان ﻻ ﺗﻜﻮن‬
                                                  ‫هﺬﻩ اﻻﺟﺮاءات ﻣﻦ اﻟﻨﻮع ‪.Public‬‬

‫- ﻓﻲ ﺣﺎﻟﺔ آﻮن اﻟﺘﺮآﻴﺐ ﻣﻌﺮف ﻓﻲ ﻓﺌﺔ ‪ Class‬ﻓﻲ ﻣﺸﺮوع ﻣﻦ اﻟﻨـﻮع ‪ ،ActiveX‬ﻓـﺎن‬
‫اﻻﺟﺮاءات اﻟﻤﻮﺟﻮدة ﻓﻲ ﺑﺮﻧﺎﻣﺠﻚ ﺗﺴـﺘﻄﻴﻊ ان ﺗﺴـﺘﻘﺒﻞ ذﻟـﻚ اﻟﺘﺮآﻴـﺐ اﻟﻤﻌـﺮف ﻓـﻲ‬
             ‫داﺧﻞ ﻣﻜﻮن ‪ COM‬اذا آﺎﻧﺖ اﻟﺨﺎﺻﻴﺔ ‪ Instancing‬ﻻ ﺗﺴﺎوي ‪.1-Private‬‬
                                                ‫101‬


                                            ‫ﺗﺨﺼﻴﺺ اﻟﻤﺘﻐﻴﺮات اﻟﻤﺮﺳﻠﺔ‬
‫ﺗﺴﺘﻄﻴﻊ ﺗﺨﺼﻴﺺ اﻟﻤﺘﻐﻴﺮات اﻟﻤﺮﺳﻠﺔ اﻣﺎ ﺑﺠﻌﻠﻬﺎ اﺧﺘﻴﺎرﻳﺔ ‪ Optional‬او ﻏﻴﺮ ﻣﺤـﺪودة‬
                                                 ‫اﻟﻌﺪد ‪.Unlimited Parameters‬‬

                                                             ‫اﻟﻤﺘﻐﻴﺮات اﻻﺧﺘﻴﺎرﻳﺔ:‬
‫اذا آﺎن ﻋﺪد اﻟﻤﺘﻐﻴﺮات اﻟﻤﺮﺳﻠﺔ ﻟﻼﺟﺮاء ﻏﻴـﺮ ﻋـﺪد اﻟﻤﺘﻐﻴـﺮات اﻟﻤﺼـﺮﺣﺔ ﻓﻴـﻪ واﻟﺘـﻲ‬
‫ﻳﺘﻮﻗﻌﻬﺎ، ﻓﺎن رﺳﺎﻟﺔ اﻟﺨﻄﺄ ﻟﻬﺎ ﻧﺼﻴﺐ. ﻟﺬﻟﻚ، ﻓـﻲ ﺣـﺎﻻت آﺜﻴـﺮة ﺟـﺪا ﺗﺮﻳـﺪ ان ﺗﺠﻌـﻞ‬
  ‫ـ‬      ‫ـ‬           ‫ـ‬       ‫ـ‬      ‫ـ‬
‫اﺟـﺮاءك ﻣ ـﺮن ﺑﻤ ـﺎ ﻓﻴـﻪ اﻟﻜﻔﺎﻳ ـﺔ وذﻟ ـﻚ ﻋـﻦ ﻃﺮﻳ ـﻖ ﺗﻌﺮﻳ ـﻒ ﻣﺘﻐﻴـﺮات اﺧﺘﻴﺎرﻳ ـﺔ ﺗﻌﻄ ـﻲ‬
                                           ‫ـ‬   ‫ـ‬      ‫ـ‬         ‫ـ ـ‬         ‫ـ‬       ‫ـ‬
‫اﻟﻤﺴﺘﺨﺪم ﺣﺮﻳـﺔ ﻣـﺎ اذا آـﺎن ﻳﺮﻳـﺪ ان ﻳﺮﺳـﻠﻬﺎ او ﻻ. ﺗـﺘﻢ هـﺬﻩ اﻟﻌﻤﻠﻴـﺔ ﻋـﻦ ﻃﺮﻳـﻖ‬
‫اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ .Optional‬واذا اردت ﻣﻌﺮﻓﺔ ﻣﺎ اذا آﺎن اﻟﻤﺴﺘﺨﺪم ﻗﺪ ارﺳـﻞ ﻗﻴﻤـﺔ‬
‫اﻟﻰ اﻻﺟﺮاء ﺗﺤﻘﻖ ﻋـﻦ ﻃﺮﻳـﻖ اﻟﺪاﻟـﺔ ‪ ،IsMissing‬ﻟﻜـﻦ اﺣـﺬر! داﻟـﺔ ‪ IsMissing‬ﺗﻌـﻮد‬
              ‫ﺑﻘﻴﻢ ﺻﺤﻴﺤﺔ ﻓﻲ ﺣﺎﻟﺔ آﻮن اﻟﻤﺘﻐﻴﺮ اﻟﻤﺮﺳﻞ ﻟﻬﺎ ﻣﻦ ﻧﻮع ‪ Variant‬ﻓﻘﻂ:‬

‫)(‪Sub Start‬‬
‫هﻨﺎ ﻧﻘﻄﺔ اﻟﺒﺪاﻳﺔ ‘‬

‫1- = ‪' MyFunction‬‬
 ‫)(‪Print MyFunction‬‬

 ‫4 = ‪' MyFunction‬‬
  ‫)2( ‪Print MyFunction‬‬
‫‪End Sub‬‬

‫‪Function MyFunction (Optional X As Variant) As Integer‬‬
  ‫‪If IsMissing(X) Then‬‬      ‫ﻟﻢ ﻳﺘﻢ ارﺳﺎل ﻗﻴﻤﺔ ﻟﻠﻤﺘﻐﻴﺮ ‘‬
     ‫1- = ‪MyFunction‬‬
  ‫‪Else‬‬                      ‫ﺗﻢ ارﺳﺎل ﻗﻴﻤﺔ ‘‬
     ‫2 ^ ‪MyFunction = X‬‬
  ‫‪End If‬‬
‫‪End Function‬‬

‫اﻟﻤﺸﻜﻠﺔ هﻨﺎ ان اﻟﻤﺘﻐﻴﺮات ﻻﺑﺪ ان ﺗﻜﻮن ﻣﻦ ﻧﻮع ‪ Variant‬ﺣﺘﻰ ﻧﺘﻤﻜﻦ اﻟﺘﺤﻘـﻖ ﻣـﻦ‬
‫ارﺳﺎﻟﻬﺎ ﻋﻦ ﻃﺮﻳﻖ اﻟﺪاﻟﺔ ‪ IsMissing‬وهﻮ اﺑﻄﺄ اﻻﻧﻮاع اﺳﺘﺨﺪام. ﻟﺬﻟﻚ، ﻳﺒﺪو ان اﻟﺤـﻞ‬
‫اﻻﻓﻀﻞ هﻮ ﻋﻦ ﻃﺮﻳﻖ وﺿﻊ ﻗﻴﻤﺔ اﻓﺘﺮاﺿﻴﺔ ﺗﺴﺘﺨﺪم ﻓﻲ ﺣﺎﻟـﺔ ﻟـﻢ ﻳـﺘﻢ ارﺳـﺎل ﻗـﻴﻢ‬
                                                                    ‫ﻟﻠﻤﺘﻐﻴﺮات:‬
                                            ‫201‬


‫)(‪Sub Start‬‬
‫هﻨﺎ ﻧﻘﻄﺔ اﻟﺒﺪاﻳﺔ ‘‬

‫1- = ‪' MyFunction‬‬
 ‫)(‪Print MyFunction‬‬

 ‫4 = ‪' MyFunction‬‬
  ‫)2( ‪Print MyFunction‬‬
‫‪End Sub‬‬

‫‪Function MyFunction (Optional X As Integer = -1) As Integer‬‬
  ‫‪If X = -1 Then‬‬     ‫ﻟﻢ ﻳﺘﻢ ارﺳﺎل ﻗﻴﻤﺔ ﻟﻠﻤﺘﻐﻴﺮ ‘‬
     ‫1- = ‪MyFunction‬‬
  ‫‪Else‬‬               ‫ﺗﻢ ارﺳﺎل ﻗﻴﻤﺔ ﻟﻠﻤﺘﻐﻴﺮ ‘‬
    ‫2 ^ ‪MyFunction = X‬‬
  ‫‪End If‬‬
‫‪End Function‬‬

 ‫اﻟﻤﺘﻐﻴﺮات اﻻﺧﺘﻴﺎرﻳﺔ ‪ Optional‬ﻻﺑﺪ ﻣﻦ ان ﺗﻜﻮن ﻓـﻲ ﻧﻬﺎﻳـﺔ ﺳﻠﺴـﺔ‬        ‫ﻣﻼﺣﻈﺔ:‬
              ‫اﻟﻤﺘﻐﻴﺮات اﻟﻤﺮﺳﻠﺔ اﻟﻰ اﻻﺟﺮاء -أي ﻣﻦ ﺟﻬﺔ اﻟﻴﻤﻴﻦ.‬

                                                    ‫ﻣﺘﻐﻴﺮات ﻏﻴﺮ ﻣﺤﺪدة اﻟﻌﺪد:‬
‫ﻓﻲ هﺬﻩ اﻟﺤﺎﻟﺔ، ﻓﺎﻧﻚ ﻻ ﺗﺤﺪد ﻋﺪدا ﻣﻌﻴﻨﺎ ﻣﻦ اﻟﻤﺘﻐﻴﺮات اﻟﺘـﻲ ﺳﻴﺴـﺘﻘﺒﻠﻬﺎ اﻻﺟـﺮاء‬
‫ﻻن اﻟﻘــﻴﻢ ﺳــﺘﻜﻮن ﻓــﻲ ﻣﺼــﻔﻮﻓﺔ ﺗﻌﺮﻓﻬــﺎ ﺑﻨﻔﺴــﻚ ﻋــﻦ ﻃﺮﻳــﻖ اﺳــﺘﺨﺪام اﻟﻜﻠﻤــﺔ‬
‫اﻟﻤﺤﺠﻮزة ‪ ،ParamArray‬ﺷﺮﻳﻄﺔ ان ﻳﻜﻮن اﻟﻤﺘﻐﻴﺮ ﻣﻦ ﻧﻮع ‪ .Variant‬هﺬا ﻣﺜـﺎل ﻟﺪاﻟـﺔ‬
                                                 ‫ﺗﻮﺟﺪ ﻣﺠﻤﻮع اﻟﻘﻴﻢ اﻟﻤﺮﺳﻠﺔ ﻟﻬﺎ:‬

‫‪Function Sum (ParamArray args() As Variant) As Long‬‬
  ‫‪Dim iCounter As Integer‬‬

  ‫)‪For iCounter = 0 To Ubound(args‬‬
    ‫)‪Sum = Sum + args(iCounter‬‬
  ‫‪Next iCounter‬‬
‫‪End Function‬‬

                                       ‫وﻻﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ آﻞ هﺬﻩ اﻻﻣﺜﻠﺔ ﺻﺤﻴﺤﺔ:‬
                                           ‫301‬


 ‫01 = ‪'Sum‬‬
‫)5 ,5( ‪Print Sum‬‬
 ‫001 = ‪'Sum‬‬
‫)02 ,02 ,02 ,02 ,02( ‪Print Sum‬‬
 ‫0001 = ‪'Sum‬‬
‫)052 ,052 ,052 ,052( ‪Print Sum‬‬



                                              ‫اﻟﺘﺤﻜﻢ ﻓﻲ ﺳﻴﺮ اﻟﺒﺮﻧﺎﻣﺞ‬
‫09% ﻣﻦ اﻻﺟﺮاءات ﻟﻦ ﺗﻜﻮن ذات ﻗﻴﻤﺔ ﻣﻌﻨﻮﻳﺔ آﺒﻴﺮة ﻣﺎﻟﻢ ﺗﺴـﺘﺨﺪم ﻋﺒـﺎرات اﻟﺘﻔـﺮع‬
‫آـ ‪ If‬و ‪ Select‬او اﻟﺤﻠﻘﺎت اﻟﺘﻜﺮارﻳﺔ آـ ‪ For … Next‬او ‪ Do … Loop‬ﻟﺘﺘﺤﻜﻢ ﻓﻲ ﺳـﻴﺮ‬
‫اﻟﺒﺮﻧﺎﻣﺞ، اﻟﻔﻘﺮات اﻟﺘﺎﻟﻴﺔ ﺗﺸﺮح ﻋﺒﺎرات اﻟﺘﻔﺮع ‪ Branch Statements‬وﻋﺒﺎرات اﻟﺘﻜـﺮار‬
                                                        ‫‪.Looping Statements‬‬

                                                    ‫اﻟﺘﻔﺮع ﺑﺎﺳﺘﺨﺪام ‪IF‬‬
‫ﺟﻤﻠﺔ ‪ If‬اﻟﺠﻤﻴﻠﺔ ﻻ ﻳﺴﺘﻐﻨﻲ ﻋﻨﻬﺎ اي ﻣﺒﺮﻣﺞ، ﻟﻴﺲ ﻓﻲ ‪ Visual Basic‬وﺣﺴﺐ واﻧﻤﺎ‬
‫ﻓﻲ ﺟﻤﻴﻊ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ. وﻣﻤﺎ ﻻ ﺷﻚ ﻓﻴﻪ ﺗﻌﺘﺒﺮ ‪ If‬ﻣﻦ اآﺜﺮ اﻟﻌﺒﺎرات اﺳـﺘﺨﺪاﻣﺎ ﻓـﻲ‬
               ‫اﻟﺒﺮﻧﺎﻣﺞ، وهﻲ ﺗﻨﺠﺰ اﻣﺎ ﻓﻲ ﺳﻄﺮ واﺣﺪ او –اﻟﻤﻔﻀﻞ- ﻋﺪة ﺳﻄﻮر:‬
‫ﻓﻲ ﺳﻄﺮ واﺣﺪ ‘‬
‫0 = ‪If X > 0 Then Y‬‬
‫‪If X > 0 Then Y = 0 Else Y = X‬‬
‫‪If X > 0 Then X = 0 : Y = 0 Else Y = X‬‬

‫ﻓﻲ ﻋﺪة ﺳﻄﻮر ‘‬
‫‪If X > 0 Then‬‬
        ‫0=‪Y‬‬
‫‪End If‬‬

‫‪If M > 0 Then‬‬
       ‫1=‪T‬‬
‫‪Else‬‬
       ‫1- = ‪T‬‬
‫‪End If‬‬

‫‪If M > 0 Then‬‬
                                           ‫401‬


        ‫1=‪T‬‬
‫‪ElseIf M < 0 Then‬‬
        ‫1- = ‪T‬‬
‫‪Else‬‬
        ‫0=‪T‬‬
‫‪End If‬‬

                                                  ‫اﺧﺘﺼﺎر اﻟﺠﻤﻞ اﻟﺸﺮﻃﻴﺔ:‬
‫اذا ﺗﺤﻘﻖ اﻟﺸﺮط او اﺻﺒﺤﺖ ﻧﺘﻴﺤﺔ اﻟﺘﻌﺒﻴﺮ اﻟﺸﺮﻃﻲ اﻟـﺬي ﻳﻠـﻲ ﺟﻤﻠـﺔ ‪ If‬هـﻮ ‪،True‬‬
                           ‫ﻓﺎن اآﻮاد اﻟﺘﻲ ﺗﻠﻲ ﻋﺒﺎرة ‪ If … Then‬ﺳﻴﺘﻢ ﺗﻨﻔﻴﺬهﺎ:‬

‫‪If Value = True Then‬‬

‫‪End If‬‬

‫‪If x <> 0 Then‬‬

‫‪End If‬‬

‫ﺗﺴﺘﻄﻴﻊ اﺧﺘﺼﺎر اﻟﺠﻤـﻞ اﻟﺸـﺮﻃﻴﺔ، ﻓﻠـﻮ ﻻﺣﻈـﺖ ﻓـﻲ ﺟﻤﻠـﺔ ‪ If‬اﻻوﻟـﻰ اﻧﻨـﺎ اﺧﺘﺒﺮﻧـﺎ‬
‫اﻟﻘﻴﻤﺔ اﻟﻤﻨﻄﻘﻴﺔ ‪ Value‬اذا ﻣﺎ آﺎﻧﺖ ﺻـﺢ او ﺧﻄـﺄ. اﻟﻤﺒﺮﻣﺠـﻮن اﻟﻤﺘﻤﺮﺳـﻮن ﻳﻔﻀـﻠﻮن‬
                                                           ‫آﺘﺎﺑﺘﻬﺎ ﺑﻬﺬا اﻟﺸﻜﻞ:‬

‫‪If Value Then‬‬

‫‪End If‬‬

‫اﻟﻜﻮد اﻟﺴﺎﺑﻖ ﺻﺤﻴﺢ واﻟﺴﺒﺐ ﻓﻲ ذﻟﻚ، ان ‪ Visual Basic‬ﻳﻌﺘﺒﺮ اي ﻗﻴﻤﺔ ﻏﻴـﺮ اﻟﺼـﻔﺮ‬
‫هﻲ ‪ True‬اﻣﺎ اﻟﺼﻔﺮ ﻓﻬﻲ ‪ False‬ﻓﻲ ﺣﺎﻟﺔ اﺧﺘﺒﺎر اﻟﺸﺮوط ﻣـﻊ ﺟﻤﻠـﺔ ‪ .If‬ﻗـﺪ ﺗﺨﺘﺼـﺮ‬
                                     ‫ﺟﻤﻠﺔ اﻟﺸﺮط اﻟﺜﺎﻧﻴﺔ اﻳﻀﺎ آﻤﺎ ﻓﻲ هﺬا اﻟﻜﻮد:‬

‫‪If x Then‬‬

‫‪End If‬‬
                                              ‫501‬


‫ﺻﺤﻴﺢ ان اﻟﻨﺘﻴﺠﺔ ﻣﻤﺎﺛﻠﺔ، ﻟﻜﻦ ﺣﺎول ﺗﺠﻨﺐ اﻻﺧﺘﺼﺎر ﻓـﻲ ﺣﺎﻟـﺔ اﺳـﺘﺨﺪام ﻗـﻴﻢ ﻏﻴـﺮ‬
‫ﻣﻨﻄﻘﻴﺔ ﺣﺘﻰ ﻻ ﺗﻈﻬﺮ ﻟﻚ ﻧﺘﺎﺋﺞ ﻏﻴﺮ ﻣﺘﻮﻗﻌﺔ. ﻻن اﻟﻘـﻴﻢ اﻟﻤﻨﺎﺳـﺒﺔ ﻟﻼﺧﺘﺼـﺎرات هـﻲ‬
‫اﻟﻘﻴﻢ اﻟﻤﻨﻄﻘﻴﺔ ﻓﻘﻂ وﻓﻴﻤﺎ ﻋﺪى ذﻟﻚ ﻗﺪ ﻳﺴﺒﺐ ﻟﻚ اﻟﻜﺜﻴﺮ ﻣﻦ اﻟﺸﻮاﺋﺐ. راﻗﺐ اﻟﻜﻮد‬
                                                                     ‫اﻟﺘﺎﻟﻲ:‬

‫3=‪x‬‬
‫4=‪y‬‬
‫اﻟﻄﺮﻳﻘﺔ اﻟﺼﺤﻴﺤﺔ ‘ ‪If x <> 0 And y <> 0 Then‬‬
‫‪If x And y Then‬‬           ‫ﻣﺸﻜﻠﺔ ﻓﻲ هﺬا اﻻﺧﺘﺼﺎر ‘‬

‫ﻟﻘﺪ اﺳـﺘﺨﺪﻣﺖ اﺳـﻠﻮب اﻻﺧﺘﺼـﺎر وﻳﺒـﺪو ان ﺟﻤﻠﺘـﻰ اﻟﺸـﺮط ﻣﺘﻤـﺎﺛﻠﺘﻴﻦ، ﻟﻜـﻦ هـﻞ‬
‫ﺗﺼﺪق ان اﻟﺸﺮﻃﻴﻦ اﻟﺴﺎﺑﻘﻴﻦ ﻣﺨﺘﻠﻔﺎن ﺗﻤﺎﻣﺎ! اذا اردت ﻣﻌﺮﻓﺔ اﻟﺴـﺒﺐ ﻗـﻢ ﺑـﺎﻟﺮﺟﻮع‬
‫اﻟﻰ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮﻳﻦ ‪ x‬و ‪ y‬ﺑﻨﻈﺎم اﻻﻋـﺪاد اﻟﺜﻨـﺎﺋﻲ 1100 و 0010 وﺳـﺘﻌﺮف اﻟﺴـﺒﺐ،‬
‫واﻟﺬي ﻧﺴﺘﻨﺘﺞ ﻣﻨـﻪ ﺑﺎﺧﺘﺼـﺎر ﻋﻠـﻰ ان ﻣﻌـﺎﻣﻼت اﻟـﺮﺑﻂ آــ ‪ And‬و ‪ Or‬ﺗﻘـﻮم ﺑﻤﻘﺎرﻧـﺔ‬
                                         ‫اﻟﻘﻴﻢ اﻟﺜﻨﺎﺋﻴﺔ ﻟﻠﻌﺪد ﺑﻐﺾ اﻟﻨﻈﺮ ﻋﻦ ﻧﻮﻋﻪ.‬

                                                 ‫اﻟﺘﻔﺮع ﺑﺎﺳﺘﺨﺪام ‪Select‬‬
                                 ‫ﺑﺎﻣﻜﺎﻧﻚ ﺗﻄﺒﻴﻖ ﻣﺒﺪأ اﻟﺘﻔﺮع ﺑﺎﺳﺘﺨﺪام ﻋﺒﺎرة ‪:Select‬‬

‫‪Select Case iDay‬‬
        ‫1 ‪Case‬‬
               ‫‪sDay‬‬   ‫”اﻟﺴﺒﺖ“ =‬
        ‫2 ‪Case‬‬
               ‫‪sDay‬‬   ‫”اﻻﺣﺪ“ =‬
        ‫…‬
        ‫7 ‪Case‬‬
               ‫‪sDay‬‬   ‫”اﻟﺠﻤﻌﺔ“ =‬
        ‫‪Case Else‬‬
               ‫‪sDay‬‬   ‫”ﻏﻴﺮ ﻣﻌﺮف“ =‬
‫‪End Select‬‬

‫ﺗﻜﻤﻦ ﻗـﻮة ﻋﺒـﺎرة ‪ Case‬ﻓـﻲ اﻣﻜﺎﻧﻴـﺔ ﺗﻄﺒﻴـﻖ اﻟﻤﻌـﺎﻣﻼت اﻟﻤﻨﻄﻘﻴـﺔ او ﺗﺤﺪﻳـﺪ ﻣﺠـﺎل‬
                                                                        ‫ﻟﻠﻘﻴﻢ:‬
                                           106


Select Case iAge
        Case Is <= 0
               sDesc =   “‫”ﻟﻢ ﻳﻮﻟﺪ‬
        Case 1 To 11
               sDesc =   “‫”ﻃﻔﻞ‬
        Case 15 To 20
               sDesc =   “‫”ﻣﺮاهﻖ‬
        Case 21 To 50
               sDesc =   “‫”رﺟﻞ‬
        Case Is >= 51
               sDesc =   “‫”ﺷﺎﻳﺐ‬
End Select

                                        :‫اﻟﻤﺰﻳﺪ اﻳﻀﺎ، ﻳﻤﻜﻨﻚ ﺗﺤﺪﻳﺪ ﻣﺠﻤﻮﻋﺔ ﻗﻴﻢ‬

Select Case sLetter
        Case “A” To “B”, “a” To “b”
               sLetter = “‫”ﺣﺮف اﺑﺠﺪي‬
        Case “0” To “9”
               sLetter = “‫”ﻋﺪد‬
        Case “.”, “:”, “ “, “;”, “?”
               sLetter = “‫”رﻣﺰ‬
        Case
               sLetter = “‫”ﻏﻴﺮ ﻣﻌﺮوف‬
End Select

                            :‫ﻟﻴﺲ هﺬا ﻓﻘﻂ، ﺑﻞ ﻳﻤﻜﻨﻚ ﺗﺤﺪﻳﺪ ﻣﺠﻤﻮﻋﺔ ﺟﻤﻞ ﺷﺮﻃﻴﺔ‬

Select Case True
        Case x > 0, Y < 0
        ‘ ‫ﺗﻌﺎدل‬
        ‘ If (X > 0) Or (Y < 0)
End Select

Select Case False
        Case x > 0, Y < 0
        ‘ ‫ﺗﻌﺎدل‬
                                                 ‫701‬


       ‫) )0 < ‪‘ If ( Not (X > 0) ) Or ( Not (Y‬‬
‫‪End Select‬‬


                                                          ‫اﻟﺤﻠﻘﺎت اﻟﺘﻜﺮارﻳﺔ‬
                        ‫ﺣﺪد اﻟﻘﻴﻤﺔ اﻻﺑﺘﺪاﺋﻴﺔ واﻟﻘﻴﻤﺔ اﻟﻨﻬﺎﺋﻴﺔ ﻟﻠﺤﻠﻘﺔ ‪:For … Next‬‬

‫‪Dim iCounter As Integer‬‬

‫4 ‪For iCounter = 2 To‬‬
       ‫ﺳﻴﺘﻜﺮر ﺗﻨﻔﻴﺬ اﻻﻣﺮ ﺛﻼث ﻣﺮات ‘ ‪Print iCounter‬‬
‫‪Next‬‬

        ‫وﻋﻠﻴﻚ ﻣﻌﺮﻓﺔ ان ﻣﻘﺪار اﻟﺰﻳﺎدة ﺳﻴﻀﺎف اﻟﻰ ﻣﺘﻐﻴﺮ اﻟﺤﻠﻘﺔ ﺣﺘﻰ ﺑﻌﺪ ﻧﻬﺎﻳﺘﻬﺎ:‬

‫‪Dim iCounter As Integer‬‬

‫3 ‪For iCounter = 1 To‬‬
        ‫‪Print iCounter‬‬
‫‪Next‬‬
‫ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ﺑﻌﺪ ﻧﻬﺎﻳﺔ اﻟﺤﻠﻘﺔ 4 وﻟﻴﺲ 3 ‘ ‪Print iCounter‬‬

                     ‫ﺗﺴﺘﻄﻴﻊ اﻟﺘﺤﻜﻢ ﻓﻲ ﻣﻘﺪار اﻟﺰﻳﺎدة او اﻟﻨﻘﺼﺎن ﺑﺎﺳﺘﺨﺪام ‪:Step‬‬

‫‪Dim iCounter As Integer‬‬

‫1- ‪For iCounter = 10 To 0 Step‬‬
       ‫‪Print iCounter‬‬
‫‪Next‬‬

‫ﻳﻤﻜﻨﻚ ﺗﻄﺒﻴﻖ ﻓﻜﺮة اﻟﺤﻠﻘﺎت اﻟﻤﺘﺪاﺧﻠﺔ ‪ Nested Loops‬آﻬﺬا اﻟﻜﻮد اﻟﺬي ﻳﻄﺒﻊ ﺟﺪول‬
                                                                   ‫اﻟﻀﺮب:‬

‫‪Dim A As Integer‬‬
‫‪Dim b As Integer‬‬
                                               108


For A = 1 To 5
   For b = A To 5
      Print A, "x", b, "=", A * b
   Next
Next

                    :Exit For ‫ﺑﺎﻣﻜﺎﻧﻚ اﻧﻬﺎء اﻟﺤﻠﻘﺔ ﻓﻲ أي وﻗﺖ ﺗﺮﻳﺪ ﺑﺎﺳﺘﺨﺪام اﻟﻌﺒﺎرة‬

Dim iCounter As Integer

For iCounter = 0 To 100
       If MsgBox("‫ ,"هﻞ ﺗﺮﻳﺪ اﻧﻬﺎء اﻟﺤﻠﻘﺔ؟‬vbYesNo ) = vbYes Then
              Exit For
       End If
…
Next

              :Collections ‫ ﻓﻬﻲ ﺗﻄﺒﻖ ﻋﻠﻰ آﺎﺋﻨﺎت اﻟﻤﺠﻤﻮﻋﺎت‬For Each ‫اﻣﺎ ﺣﻠﻘﺔ‬

Dim ctrl As Control

‘ ‫ﻣﺤﺎذاة ﺟﻤﻴﻊ اﻻدوات اﻟﻰ اﻟﻴﺴﺎر‬
For Each ctrl In Controls
    ctrl.Left = 0
Next
               :Variant ‫او ﺣﺘﻰ اﻟﻤﺼﻔﻮﻓﺎت ﺷﺮﻳﻄﺔ ان ﻳﻜﻮن ﻣﺘﻐﻴﺮ اﻟﺤﻠﻘﺔ ﻣﻦ اﻟﻨﻮع‬

Dim X(100) As Integer
Dim Y As Variant

‘ ‫آﻮد ﻻﺳﻨﺎد ﻗﻴﻢ ﻟﻠﻤﺼﻔﻮﻓﺔ‬
…

‘ ‫ﻃﺒﺎﻋﺔ ﻣﺤﺘﻮﻳﺎﺗﻬﺎ‬
For Each Y In X
    Print Y
Next
                                             ‫901‬


‫اﻣﺎ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﺤﻠﻘﺔ ‪ Do … Loop‬ﻓﻬﻲ اآﺜﺮ ﻣﺮوﻧﺔ ﻣﻦ اﻟﺤﻠﻘـﺔ ‪ ،For … Next‬ﻻﻧـﻚ ﻻ‬
        ‫ﺗﺤﺪد ﻋﺪد ﻣﻌﻴﻦ ﻣﻦ اﻟﺘﻜﺮار واﻧﻤﺎ ﺟﻤﻠﺔ ﺷﺮﻃﻴﺔ ﺑﺎﺳﺘﺨﺪام ‪ While‬او ‪:Until‬‬

‫‪", vbYesNo ) = vbYes‬هﻞ ﺗﺮﻳﺪ اﻧﻬﺎء اﻟﺤﻠﻘﺔ؟"(‪Do While MsgBox‬‬
      ‫…‬
‫‪Loop‬‬

‫‪", vbYesNo ) = vbNo‬هﻞ ﺗﺮﻳﺪ اﻧﻬﺎء اﻟﺤﻠﻘﺔ؟"(‪Do Until MsgBox‬‬
       ‫…‬
‫‪Loop‬‬

‫ﺳــﺘﺘﻢ ﻋﻤﻠﻴــﺔ ﺗﻨﻔﻴــﺬ اﻟﺤﻠﻘــﺔ ﻣﺎداﻣــﺖ اﻟﺠﻤﻠــﺔ اﻟﺸــﺮﻳﻂ ﺻــﺤﻴﺤﺔ ‪ True‬ﻓــﻲ ﺣــﺎل‬
‫اﺳﺘﺨﺪام اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠـﻮزة ‪ While‬او ‪ False‬ﻓـﻲ ﺣـﺎل اﺳـﺘﺨﺪام اﻟﻜﻠﻤـﺔ اﻟﻤﺤﺠـﻮزة‬
‫‪ .Until‬واذا اردت ﺗﻨﻔﻴﺬ اﻟﺤﻠﻘﺔ اﻟﺘﻜﺮارﻳﺔ ﻣﺮة واﺣﺪ ﻋﻠﻰ اﻻﻗﻞ، ﺿﻊ ﺣﻤﻞ اﻟﺸـﺮط ﻓـﻲ‬
                                                                    ‫اﺳﻔﻞ اﻟﺤﻠﻘﺔ:‬

‫‪Do‬‬
      ‫…‬
‫‪", vbYesNo ) = vbNo‬هﻞ ﺗﺮﻳﺪ اﻧﻬﺎء اﻟﺤﻠﻘﺔ؟"(‪Loop While MsgBox‬‬

‫‪Do‬‬
      ‫…‬
‫‪", vbYesNo ) = vbYes‬هﻞ ﺗﺮﻳﺪ اﻧﻬﺎء اﻟﺤﻠﻘﺔ؟"(‪Loop Until MsgBox‬‬

‫ﺑﺎﻣﻜﺎﻧﻚ وﺿﻊ ﺟﻤﻠﺔ اﻟﺸﺮط ﻓﻲ داﺧـﻞ اﻟﺤﻠﻘـﺔ اﻳﻀـﺎ ﺑﺎﺳـﺘﺨﺪام ﻋﺒـﺎرة ‪ If‬او ‪،Select‬‬
                                       ‫ﻟﻜﻦ ﻻ ﺗﻨﺴﻰ اﻧﻬﺎء اﻟﺤﻠﻘﺔ ﺑﺎﻟﻌﺒﺎرة ‪:Exit Do‬‬

‫‪Do‬‬
       ‫‪", vbYesNo ) = vbYes Then‬هﻞ ﺗﺮﻳﺪ اﻧﻬﺎء اﻟﺤﻠﻘﺔ؟"(‪If MsgBox‬‬
              ‫‪Exit Do‬‬
       ‫‪End If‬‬
‫…‬
‫‪Loop‬‬
                                                  ‫011‬


                                  ‫اﻟﺘﺤﻮﻳﻞ ﺑﻴﻦ ‪ For … Next‬و ‪:Do … Loop‬‬
‫ﺗﺴﺘﻄﻴﻊ ﺗﺤﻮﻳﻞ ﺣﻠﻘﺔ ‪ For … Next‬اﻟـﻰ ﺣﻠﻘـﺔ ‪ Do … Loop‬واﻟﻌﻜـﺲ ﺻـﺤﻴﺢ، ﻟﻜـﻦ‬
‫ﻋﻠﻴﻚ اﻻﻧﺘﺒﺎﻩ اﻟﻰ ان اﻟﻘﻴﻢ اﻟﺘﻲ ﺗﺤﺪدهﺎ ﻓﻲ ﺑﺪاﻳﺔ اﻟﺤﻠﻘـﺔ ‪ For … Next‬ﺗﻤﺜـﻞ ﻋـﺪد‬
           ‫اﻟﺘﻜﺮار ﺣﺘﻰ وان ﺗﻐﻴﺮت، ﻓﺒﺎﻟﺮﻏﻢ ﻣﻦ ان اﻟﺤﻠﻘﺘﻴﻦ اﻟﺘﺎﻟﻴﺘﻴﻦ ﻣﺘﺸﺎﺑﻬﺘﻴﻦ:‬

‫5=‪A‬‬
‫‪For iCounter = 1 To A‬‬
       ‫…‬
‫‪Next‬‬

‫1 = ‪iCounter‬‬
‫‪Do‬‬
       ‫…‬
       ‫1 + ‪iCounter = iCounter‬‬
‫‪Loop Until iCounter > A‬‬

‫اﻻ ان اﻻﺧﺘﻼف ﺳﻴﻈﻬﺮ ﻓﻲ ﺣﺎل ﻣﺎ اذا ﺗﻢ ﺗﻐﻴﻴـﺮ ﻗﻴﻤـﺔ اﻟﻤﺘﻐﻴـﺮ ‪ ،A‬ﻓﺎﻟﺤﻠﻘـﺔ … ‪For‬‬
‫‪ Next‬ﺳــﻴﺘﻢ ﺗﻨﻔﻴــﺬﻩ داﺋﻤــﺎ 5 ﻣــﺮات ﺣﺘــﻰ وان ﺗﻐﻴــﺮت ﻓﻴﻤــﺔ اﻟﻤﺘﻐﻴــﺮ ‪ A‬ﻓــﻲ داﺧــﻞ‬
‫اﻟﺤﻠﻘﺔ، ﺑﻴﻨﻤﺎ ﺗﻐﻴﻴﺮ اﻟﻘﻴﻤﺔ ﻳﺆﺛﺮ ﺑﺸﻜﻞ آﺒﻴـﺮ ﻋﻠـﻰ ﻋـﺪد ﻣـﺮات ﺗﻜـﺮار اﻟﺤﻠﻘـﺔ … ‪Do‬‬
                                                                                 ‫‪.Loop‬‬


                                                                         ‫ﺗﺤﺴﻴﻦ اﻟﻜﻔﺎءة‬
‫ﺑﺼﻔﺔ ﻋﺎﻣـﺔ، ﻓـﺎن اﻟﻤﺼـﻄﻠﺢ ﺗﺤﺴـﻴﻦ اﻟﻜﻔـﺎءة ‪ Optimization‬ﻳﻄﻠـﻖ ﻋﻠـﻰ اﺳـﺎﻟﻴﺐ‬
  ‫ـ‬         ‫ـ‬        ‫ـ‬     ‫ـ‬    ‫ـ‬
‫ﺑﺮﻣﺠﻴ ـﺔ ﺗﺘﺒ ـﻊ ﻟﺰﻳ ـﺎدة ﺳ ـﺮﻋﺔ ﺗﻨﻔﻴ ـﺬ اﻟﻜ ـﻮد او اﻟﺘﻘﻠﻴ ـﻞ ﻣ ـﻦ اﺳ ـﺘﻬﻼك ﻣﺼ ـﺎدر اﻟﻨﻈ ـﺎم‬
                                              ‫ـ‬      ‫ـ‬         ‫ـ‬      ‫ـ‬      ‫ـ‬      ‫ـ‬
‫‪ System Resources‬وﻏﻴﺮهــﺎ. اﻣــﺎ ﻓــﻲ ﻣﻮﺿــﻮع هــﺬﻩ اﻟﻔﻘــﺮة ﻓﺴــﻨﻨﺎﻗﺶ ﺗﻘﻨﻴــﺎت‬
‫ﻟﺘﺤﺴﻴﻦ اﻟﻜﻔﺎءة واﻟﺨﺎﺻﺔ ﻟﻌﻤﻠﻴـﺔ اﻟﺘﺮﺟﻤـﺔ واﻟﺘـﻲ ﻳﻮﻓﺮهـﺎ ‪ Visual Basic‬ﻣـﻦ ﺧـﻼل‬
‫ﺧﺎﻧـﺔ اﻟﺘﺒﻮﻳـﺐ ‪ Compile‬اﻟﻤﻮﺟـﻮدة ﻓـﻲ ﺻـﻨﺪوق ﺣـﻮار ﺧﺼـﺎﺋﺺ اﻟﻤﺸـﺮوع ‪Project‬‬
                                                                             ‫‪.Properties‬‬

                                                     ‫‪ P-Code‬و ‪Native Code‬‬
‫ﻋﻨﺪﻣﺎ ﺗﻘﻮم ﺑﺘﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ -ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ 5‪ -F‬ﺳـﻴﻘﻮم ﻣﻔﺴـﺮ ‪ Visual Basic‬ﺑﺘﻨﻔﻴـﺬ‬
     ‫ـ‬     ‫ـ‬                    ‫ـ‬     ‫ـ‬
‫ﺳـﻄﺮ ﺗﻠـﻮ اﻻﺧـﺮ. ﻗﺒـﻞ ﻋﻤﻠﻴـﺔ ﺗﻨﻔﻴـﺬ اﻟﺴـﻄﺮ، ﻳﻘـﻮم ‪ Visual Basic‬ﺑﺘﺤﻮﻳـﻞ ﺷـﻴﻔﺮة‬
                                            ‫ـ‬     ‫ـ‬      ‫ـ‬     ‫ـ‬     ‫ـ‬     ‫ـ‬
 ‫ـ‬
‫اﻟﺴـﻄﺮ اﻟـﻰ ﺷـﻴﻔﺮة ﻣـﻦ ﻧـﻮع ‪ P-Code‬ﺣﺘـﻰ ﻳﻔﻬﻤﻬـﺎ اﻟﻤﻔﺴـﺮ وﻳﻨﻔـﺬ اﻟﺴـﻄﺮ. اﻣـﺎ‬
                                             ‫111‬


‫‪ Native Code‬ﻓﻬﻲ ﺗﺤﻮﻳﻞ اﻟﺸﻴﻔﺮة اﻟﻤﺼـﺪرﻳﺔ اﻟـﻰ ﻟﻐـﺔ اﻻﻟـﺔ ‪Machine Language‬‬
‫ﻳﻔﻬﻤﺎ اﻟﺠﻬﺎز ﻣﺒﺎﺷﺮة. اﻟﻤﻴﺰة ﻓﻲ اﻟﻤﻠﻔﺎت اﻟﺘﻨﻔﻴﺬﻳﺔ ﻣـﻦ ﻧـﻮع ‪ P-Code‬هـﻲ ﺣﺠﻤﻬـﺎ‬
‫اﻟﺼﻐﻴﺮ ﻧﺴﺒﻴﺎ آﺬﻟﻚ ﺗﻮاﻓﻘﻴﺘﻬﺎ اﻟﻤﻄﻠﻘﺔ ﻣـﻊ اآـﻮاد اﻟﺘﻨﻔﻴـﺬ داﺧـﻞ ﺑﻴﺌـﺔ ‪.Visual Basic‬‬
‫اﻟﻤﺰﻳﺪ اﻳﻀﺎ، اآﻮاد ‪ P-Code‬ﺗﻜﻮن ﻋﺮﺿﺔ ﻻﺣﺪاث اﻧﻬﻴﺎر اﻟﺒﺮﻧﺎﻣﺞ ﺑﻨﺴﺒﺔ اﻗﻞ ﺑﻜﺜﻴﺮ ﻣـﻦ‬
‫اآﻮاد ‪ .Native Code‬ﻣﻦ ﻧﺎﺣﻴﺔ اﺧـﺮى، اآـﻮاد ‪ P-Code‬اﺑﻄـﺄ ﻣـﻦ اآـﻮاد ‪Native Code‬‬
‫ﻻﻧﻬﺎ ﻟﻴﺴﺖ اآﻮاد ‪ Machine Language‬ﺣﻘﻴﻘﻴﺔ ﺑـﻞ هـﻲ ﻟﻐـﺔ ﻣﻔﺴـﺮ ‪Visual Basic‬‬
‫ﻓﻘﻂ. ﻓـﻲ ﺣﺎﻟـﺔ اﺧﺘﻴـﺎرك ﻟﺘﺮﺟﻤـﺔ اﻟـﻰ اآـﻮاد ﻣـﻦ ﻧـﻮع ‪ ،Native Code‬ﻓﺴـﻴﻮﻓﺮ ﻟـﻚ‬
   ‫ـ‬     ‫ـ‬                ‫ـ‬
‫‪ Visual Basic‬ﺧﻴـﺎرات اﺿـﺎﻓﻴﺔ ﺗﺠ ـﺪهﺎ ﻓـﻲ ﺧﺎﻧـﺔ اﻟﺘﺒﻮﻳـﺐ ‪ Compile‬اﻟﻤﻮﺟـﻮدة ﻓ ـﻲ‬
                                   ‫ـ‬       ‫ـ‬     ‫ـ‬       ‫ـ‬       ‫ـ‬
                                                ‫ﺻﻨﺪوق اﻟﺤﻮار ‪:Project Properties‬‬

                                                ‫‪:Optimize for Fast Code‬‬
‫ﺳﻴﺤﺎول اﻟﻤﺘﺮﺟﻢ ﻓﻲ هﺬا اﻻﺧﺘﻴﺎر ﺑﺘﻨﻈﻴﻢ ﺗﻌﻠﻴﻤﺎت ﻟﻐﺔ اﻻﻟـﺔ ﺑﺤﻴـﺚ ﺗﻌﻄـﻲ اﻗﺼـﻰ‬
         ‫ﻧﺘﺎﺋﺞ ﻟﺴﺮﻋﺔ ﺗﻨﻔﻴﺬ اﻻآﻮاد ﺑﻐﺾ اﻟﻨﻈﺮ ﻋﻦ ﺣﺠﻢ اﻟﻤﻠﻒ اﻟﺘﻨﻔﻴﺬي ‪. EXE‬‬

                                              ‫‪:Optimize for Small Code‬‬
‫ﺳﻴﺤﺎول اﻟﻤﺘﺮﺟﻢ ﻓﻲ هﺬا اﻻﺧﺘﻴﺎر ﺑﺘﻘﻠﻴﺺ ﺣﺠﻢ اﻟﻤﻠﻒ اﻟﺘﻨﻔﻴﺬ اﻗﺼﻰ ﻣـﺎ ﻳﺴـﺘﻄﻴﻊ‬
                                    ‫ﺑﻐﺾ اﻟﻨﻈﺮ ﻋﻦ ﺳﺮﻋﺔ ﺗﻨﻔﻴﺬ اﻻآﻮاد ﻓﻴﻪ.‬

            ‫ﺎ‬
 ‫ﺗﻮﺟﺪ ﻋﻼﻗﺔ ﻋﻜﺴﻴﺔ ﺑﻴﻦ اﻟﺨﻴﺎرﻳﻦ اﻟﺴﺎﺑﻘﻴﻦ، ﻓﻐﺎﻟﺒً ﻣﺎ ﻳﺘﺴﺒﺐ‬               ‫ﻣﻼﺣﻈﺔ:‬
 ‫ﺗﻘﻠﻴﺺ ﺣﺠﻢ اﻟﺸﻴﻔﺮة ﻓﻲ ﺗﺨﻔﻴﺾ ﺳﺮﻋﺔ اﻟﺒﺮﻧﺎﻣﺞ، وﻓﻲ اﻻﺗﺠﺎة‬
                                               ‫ﺎ‬
 ‫اﻵﺧﺮ، ﻏﺎﻟﺒً ﻣﺎ ﻳﺘﺴﺒﺐ ﺗﺤﺴﻴﻦ ﺳﺮﻋﺔ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ إﻟﻰ زﻳﺎدة‬
                                              ‫ﺣﺠﻢ اﻟﻤﻠﻒ.‬

                                                      ‫‪:No Optimization‬‬
‫ﻟﻦ ﻳﻘـﻮم اﻟﻤﺘـﺮﺟﻢ ﺑـﺎي ﻣﺤـﺎوﻻت ﻟﻌﻤﻠﻴـﺎت ﺗﺤﺴـﻴﻦ اﻟﻜﻔـﺎءة ‪ Optimization‬ﻟﻠﻤﻠـﻒ‬
                                                                  ‫اﻟﺘﻨﻔﻴﺬي.‬

                                                    ‫‪:Favor Pentium Pro‬‬
‫اذا آﺎن اﻟﺒﺮﻧﺎﻣﺞ ﺳﻴﻌﻤﻞ ﻋﻠﻰ ﻣﻌﺎﻟﺞ ﻣﻦ ﻧﻮع ‪ Pentium Pro‬ﻓﻬﺬا اﻻﺧﺘﻴﺎر ﺳﻴﺰﻳﺪ ﻣﻦ‬
                                ‫ﺳﺮﻋﺔ ﺗﻨﻔﻴﺬ اﻟﺘﻌﻠﻴﻤﺎت وﺧﺼﻮﺻﺎ اﻟﺮﻳﺎﺿﻴﺔ ﻣﻨﻬﺎ.‬
                                             ‫211‬


                                               ‫‪:Create Symbolic Debug Info‬‬
‫ﺳﻴﻀﻴﻒ هﺬا اﻻﺧﺘﻴﺎر ﺗﻌﻠﻴﻤﺎت اﺿﺎﻓﻴﺔ اﻟﻰ اﻟﻤﻠﻒ اﻟﺘﻨﻔﻴﺬي ﻻﻋﻄﺎءﻩ اﻣﻜﺎﻧﻴﺔ اﻟﺘﻨﻘـﻴﺢ‬
‫‪ Debug‬ﺑﺎﺳﺘﺨﺪام ﺑﺮاﻣﺞ ﺗﻨﻘﻴﺢ اﻟﻤﻠﻔﺎت اﻟﺘﻨﻔﻴﺬﻳﺔ آﺒﺮﻧﺎﻣﺞ اﻟﺘﻨﻘﻴﺢ اﻟـﺬي ﺗـﻮﻓﺮﻩ ﺑﻴﺌـﺔ‬
                                   ‫‪ .Microsoft Visual C‬ﻧﺼﻴﺤﺔ ﻟﻚ، اﻟﻎ هﺬا اﻻﺧﺘﻴﺎر.‬

                                 ‫إﻋﺪادات ‪Advanced Optimization‬‬
‫ﻳﻤﻜﻨﻚ ‪ Visual Basic‬ﻣﻦ ﺗﺨﺼﻴﺺ ﺑﻌـﺾ ﺧﻴـﺎرات ﺗﺤﺴـﻴﻦ اﻟﻜﻔـﺎءة اﻟﻤﺘﻘﺪﻣـﺔ واﻟﺘـﻲ‬
                              ‫ﺗﺠﺪهﺎ ﻓﻲ ﺻﻨﺪوق ﺣﻮار ‪:Advanced Optimization‬‬

                                                    ‫‪:Assume No Aliasing‬‬
‫هﺬا اﻻﺧﺘﻴﺎر ﺳﻴﺰﻳﺪ ﻣﻦ ﺳﺮﻋﺔ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﻟﻜﻦ ﻣـﻦ اﻟﻀـﺮوري ﺟـﺪا ﻋـﺪم ﺗﻄﺒﻴـﻖ‬
‫ﻣﺒﺪأ اﻻﺳﺘﻌﺎرة. واﻻﺳﺘﻌﺎرة –ﺑﺸﻜﻞ ﻣﺒﺴﻂ- هﻲ ﻋﻤﻠﻴﺔ اﺳﺘﻌﺎرة اﺳﻢ ﻟﻤﺘﻐﻴـﺮ ﻋـﺎم‬
                                            ‫وارﺳﺎﻟﻪ اﻟﻰ اﺟﺮاء ﺑﺎﻟﻤﺮﺟﻊ ‪:ByRef‬‬

‫‪Dim X‬‬

‫)‪Sub MySub ( Y As Integer‬‬
  ‫4=‪Y‬‬
‫‪End Sub‬‬

‫)(‪Sub AliasingSub‬‬
  ‫ﻋﻤﻠﻴﺔ اﻻﺳﺘﻌﺎرة ‘‬
  ‫‪MySub X‬‬
‫‪End Sub‬‬

                                         ‫‪:Remove Array Bound Checks‬‬
‫ﻋﺪم اﻟﺘﺤﻘﻖ ﻣﻦ رﻗﻢ ﻓﻬﺮس اﻟﻤﺼﻔﻮﻓﺔ ‪ Array Index‬ﻣﻤﺎ ﻳﺰﻳﺪ ﻣـﻦ ﺳـﺮﻋﺔ اﻟﺘﻌﺎﻣـﻞ‬
                                                           ‫ﻣﻊ اﻟﻤﺼﻔﻮﻓﺎت.‬

                                      ‫‪:Remove Integer Overflow Checks‬‬
‫ﻋﺪم اﻟﺘﺤﻘﻖ ﻣﻦ اﻟﻘﻴﻤﺔ اﻟﻤﺮﺳﻠﺔ اﻟﻰ اﻟﻤﺘﻐﻴﺮات اﻟﺼﺤﻴﺤﺔ ﻓﻴﻤـﺎ ﻟـﻮ آﺎﻧـﺖ اآﺒـﺮ ﻣـﻦ‬
                                                                 ‫اﻟﻤﺠﺎل ﻟﻢ ﻻ.‬

                                   ‫‪:Remove Floating Point Error Checks‬‬
 ‫ﻣﺜﻞ اﻻﺧﺘﻴﺎر اﻟﺴﺎﺑﻖ، ﻟﻜﻨﻪ ﺧﺎص ﻟﻼﻋﺪاد ﻣﻦ ﻧﻮع اﻟﻔﺎﺻﻠﺔ اﻟﻌﺎﺋﻤﺔ ‪.Floating Point‬‬
                                                  ‫311‬


                              ‫‪:Allow Unrounded Floating Point Operations‬‬
                                     ‫ﻟﻠﺤﺼﻮل ﻋﻠﻰ دﻗﺔ اآﺒﺮ ﻻﻋﺪاد اﻟﻔﻮاﺻﻞ اﻟﻌﺎﺋﻤﺔ.‬

                                 ‫‪:Remove Safe Pentium™ FDIV Checks‬‬
‫ﺳﻴﺰﻳﺪ ﻣـﻦ ﺳـﺮﻋﺔ ﻋﻤﻠﻴـﺔ اﻟﻘﺴـﻤﺔ ﻟﻜﻨـﻪ ﻗـﺪ ﻳـﺆدي اﻟـﻰ ﻧﺘـﺎﺋﺞ ﺧﺎﻃﺌـﺔ ﻟﻤﻌﺎﻟﺠـﺎت‬
                                       ‫‪ Pentium‬واﻟﺘﻲ ﺗﻌﺎﻧﻲ ﻣﻦ ﻣﺸﻜﻠﺔ ‪.FDIV‬‬

‫اﻋﻴﺪ واآﺮر، ﻣﺼﻄﻠﺢ ﺗﺤﺴﻴﻦ اﻟﻜﻔﺎءة ‪ Optimization‬ﻳﻄﻠﻖ ﻋﻠﻰ اﺳﺎﻟﻴﺐ وﺧﻮارزﻣﻴﺎت‬
  ‫ـ‬         ‫ـ‬         ‫ـ‬    ‫ـ‬    ‫ـ‬
‫ﺑﺮﻣﺠﻴ ـﺔ ﺗﺘﺒ ـﻊ ﻟﺰﻳ ـﺎدة ﺳ ـﺮﻋﺔ ﺗﻨﻔﻴ ـﺬ اﻟﻜ ـﻮد او اﻟﺘﻘﻠﻴ ـﻞ ﻣ ـﻦ اﺳ ـﺘﻬﻼك ﻣﺼ ـﺎدر اﻟﻨﻈ ـﺎم‬
                                              ‫ـ‬      ‫ـ‬         ‫ـ‬      ‫ـ‬      ‫ـ‬      ‫ـ‬
   ‫ـ‬             ‫ـ‬      ‫ـ‬       ‫ـ‬         ‫ـ‬      ‫ـ ـ‬        ‫ـ‬
‫‪ System Resources‬وﻏﻴﺮه ـﺎ. اﻣ ـﺎ ﻓ ـﻲ ه ـﺬﻩ اﻟﻔﻘ ـﺮة ﻓﺨﺼﺼ ـﺖ اﺳ ـﺎﻟﻴﺐ ﻟﺘﺤﺴ ـﻴﻦ‬
‫اﻟﻜﻔﺎءة واﻟﺨﺎﺻﺔ ﺑﻌﻤﻠﻴﺔ اﻟﺘﺮﺟﻤﺔ واﻟﺘﻲ ﻳﻮﻓﺮهﺎ ‪ Visual Basic‬ﻣﻦ ﺧﻼل ﺧﺎﻧﺔ اﻟﺘﺒﻮﻳﺐ‬
‫‪ Compile‬اﻟﻤﻮﺟﻮدة ﻓﻲ ﺻﻨﺪوق اﻟﺤﻮار ﺧﺼﺎﺋﺺ اﻟﻤﺸﺮوع ‪ .Project Properties‬ﺗﺬآﺮ‬
‫ان هﺬﻩ اﻻﺧﺘﻴﺎرات ﻗﺪ ﺗﺴﺒﺐ ﻣﺸﺎآﻞ او –ﻓﻲ اﺣﺴـﻦ اﻻﺣـﻮال- ﻧﺘـﺎﺋﺞ ﻏﻴـﺮ ﻣﺘﻮﻗﻌـﺔ‬
                   ‫ﻓﺎﺣﺮص ﻋﻠﻰ ﺗﻐﻴﻴﺮهﺎ ﺑﺸﻜﻞ دﻗﻴﻖ، وﻻ ﺗﻘﻮل ان ﺗﺮآﻲ ﻣﺎ ﻧﺒﻬﻨﻲ!‬
                                                ‫411‬


                                         ‫اﻟﻔﺼﻞ اﻟﺮاﺑﻊ‬
                            ‫ﻣﻜﺘﺒﺎت ‪ VB‬و ‪VBA‬‬


‫ﻳﻮﻓﺮ ﻟﻚ ‪ Visual Basic‬ﻣﺌـﺎت اﻻﺟـﺮاءات واﻟﻜﺎﺋﻨـﺎت اﻟﻤﻀـﻤﻨﺔ ﻓـﻲ ﻣﻜﺘﺒـﺎت ‪ VB‬و ‪VBA‬‬
‫واﻟﺘﻲ ﻻ ﻏﻨﻰ ﻋﻨﻬﺎ ﻓﻲ ﺑﺮاﻣﺠﻚ اﻟﺠﺪﻳﺔ، ﺻﺤﻴﺢ اﻧـﻚ ﺗﺴـﺘﻄﻴﻊ ﻣﺤﺎآـﺎة ﻣﻌﻈـﻢ هـﺬﻩ‬
   ‫ـ‬       ‫ـ‬           ‫ـ‬      ‫ـ‬
‫اﻟ ـﺪوال ﺑﻜﺘﺎﺑ ـﺔ اآ ـﻮاد ﻻﻧﺠﺎزه ـﺎ، اﻻ ان اﺳ ـﺘﺨﺪام اﻻﺟ ـﺮاءت واﻟ ـﺪوال اﻟﻤﺸ ـﻤﻮﻟﺔ ﻓ ـﻲ‬
                                         ‫ـ‬              ‫ـ‬         ‫ـ‬     ‫ـ‬           ‫ـ‬
‫ﻣﻜﺘﺒﺎت ‪ Visual Basic‬ﻳﻌﺘﺒﺮ اﻓﻀـﻞ ﺑﻜﺜﻴـﺮ ﻣـﻦ اﻧﺠﺎزهـﺎ ﺑﻨﻔﺴـﻚ ﻣـﻦ ﻣﻨﻈـﻮر ﺗﺤﺴـﻴﻦ‬
‫اﻟﻜﻔﺎءة ‪ ،Optimization‬ﻓﻬﺬﻩ اﻟﺪوال ﺻـﻤﻤﻬﺎ ﻣﺒﺮﻣﺠـﻮن ﻣﺤﺘﺮﻓـﻮن ﺑﻠﻐـﺎت اﺧـﺮى ﻣﻤـﺎ‬
‫ﻳﺠﻌﻞ ﺗﻨﻔﻴﺬهﺎ اﺳﺮع ﺑﻜﺜﻴﺮ ﻣﻦ اآﻮادك اﻟﻤﻜﺘﻮﺑﺔ ﺑـ ‪ .Visual Basic‬ﻳﺄﺧﺬك هـﺬا اﻟﻔﺼـﻞ‬
‫ﻓﻲ ﺟﻮﻟﺔ ﻣﻊ اﻟﻌﺸﺮات ﻣﻦ هـﺬﻩ اﻟـﺪوال واﻻﺟـﺮاءت واﻟﺘـﻲ ﺳـﺄﺗﻄﺮق اﻟﻴﻬـﺎ ﺑﺎﺧﺘﺼـﺎر‬
   ‫ـ ـ‬        ‫ـ‬      ‫ـ‬
‫ﺑﺎﺧﺘﺼـﺎر، اﻣ ـﺎ اذا اردت ﺷ ـﺮﺣﺎ واﻓﻴـﺎ ﻟﻬ ـﺎ ﻓﻤﻜﺘﺒ ـﺔ ‪ MSDN‬ﺑﺎﻧﺘﻈـﺎرك ﺣﺘ ـﻰ ﺗﺒﺤ ـﺮ ﻓ ـﻲ‬
                                     ‫ـ‬      ‫ـ ـ‬           ‫ـ‬             ‫ـ‬       ‫ـ‬
                                                                             ‫ﺻﻔﺤﺎﺗﻬﺎ.‬


                                                                ‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻻﻋﺪاد‬
‫ﻳــﻮﻓﺮ ﻟــﻚ ‪ Visual Basic‬ﻋﺸــﺮات اﻟﻤﻌــﺎﻣﻼت ‪ Operators‬واﻟــﺪوال اﻟﺨﺎﺻــﺔ ﺑﺎﻻﻋــﺪاد‬
‫ﺑﺎﺧﺘﻼف اﻧﻮاﻋﻬﺎ ‪ .... Long ،Integer ،Byte‬اﻟـﺦ، ﺑﺎﻻﺿـﺎﻓﺔ اﻟـﻰ دوال رﻳﺎﺿـﻴﺔ آـﺪوال‬
                                                        ‫اﻟﻤﺜﻠﺜﺎت او اﻟﺪوال اﻻﺳﻴﺔ.‬

                                                           ‫اﻟﻤﻌﺎﻣﻼت اﻟﺮﻳﺎﺿﻴﺔ‬
‫ﻳﻮﻓﺮ ﻟﻚ ‪ Visual Basic‬اﻟﻤﻌﺎﻣﻼت اﻻرﺑـﻊ اﻟﺮﺋﻴﺴـﻴﺔ +، -، * و /، وﻓـﻲ ﺣﺎﻟـﺔ ﺗﻄﺒﻴﻘﻬـﺎ‬
‫ﻋﻠﻰ اﻧﻮاع ﻣﺨﺘﻠﻔﺔ ﻣـﻦ اﻟﻘـﻴﻢ، ﻓـﺎن اﻟﻘـﻴﻢ اﻻﺑﺴـﻂ ﺳـﺘﺘﺤﻮل ﻣﺆﻗﺘـﺎ اﻟـﻰ اﻻﻋﻘـﺪ –‬
‫‪ Integer‬اﻟﻰ ‪ Long‬و ‪ Single‬اﻟﻰ ‪ ،Double‬ﺑﺎﻟﻨﺴـﺒﺔ ﻟﻤﻌﺎﻣـﻞ اﻟﻘﺴـﻤﺔ / ﻓﻬـﻮ ﻳﻘـﻮم‬
‫ﺑﺘﺤﻮﻳﻞ ﺟﻤﻴﻊ اﻟﻘﻴﻢ اﻟﻤﺘﻤﺜﻠﺔ ﻓﻲ اﻟﺤﺪﻳﻦ اﻻﻳﻤﻦ واﻻﻳﺴﺮ اﻟﻰ اﻟﻨـﻮع ‪ ،Double‬ﻟـﺬﻟﻚ‬
‫ﻳﻨﺼﺢ ﺑﺎﺳﺘﺨﺪام ﻣﻌﺎﻣﻞ اﻟﻘﺴﻤﺔ اﻟﺼﺤﻴﺤﺔ \ ﻣﻊ اﻟﻤﺘﻐﻴﺮات اﻟﺼﺤﻴﺤﺔ ‪Integer ،Byte‬‬
                                     ‫و ‪ Long‬ﻓﻬﻮ اﺳﺮع ارﺑﻊ ﻣﺮات ﻣﻦ اﻟﻤﻌﺎﻣﻞ /:‬
                                                  ‫511‬


‫‪Dim X As Long, Y As Long, Z As Long‬‬
‫‪Z=X/Y‬‬
‫هﺬا اﺳﺮع ‘ ‪Z = X \ Y‬‬

‫آﺬﻟﻚ ﻣﻌﺎﻣﻞ اﻻس ^ ﻓﻬﻮ ﻳﺤﻮل ﺟﻤﻴﻊ اﻟﻘﻴﻢ اﻟﻰ اﻟﻨﻮع ‪ ،Double‬وﻓـﻲ اﺣﻴـﺎن آﺜﻴـﺮة‬
‫ﻟﻦ ﺗﺤﺘﺎج اﻻ ﻟﻠﻤﺘﻐﻴﺮات اﻟﺼﺤﻴﺤﺔ، ﻟﺬﻟﻚ ﻳﻨﺼﺢ ﺑﺎﺳﺘﺨﺪام ﻣﻌﺎﻣـﻞ اﻟﻀـﺮب ﻋﻮﺿـﺎ ﻋـﻦ‬
                                                                    ‫اﻻس:‬

‫,‪Dim X As Long, Y As Long‬‬
‫3^‪Y=X‬‬
‫‪Y=X*X*X‬‬

‫اﻣﺎ ﻣﻌﺎﻣﻞ ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ ‪ MOD‬ﻓﻴﻘﻮم ﺑﺘﺤﻮﻳﻞ اﻟﻘﻴﻢ اﻟـﻰ ‪ Long‬ﻣﻤـﺎ ﻻ ﻳﻌﻄـﻲ دﻗـﺔ‬
‫ﻓﻲ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻧﻮاع اﻟﻔﺎﺻﻠﺔ اﻟﻌﺎﺋﻤﺔ اﻻﺧﺮى آــ ‪ Double‬و ‪ ،Single‬ﺗﺴـﺘﻄﻴﻊ ﺗﻄـﻮﻳﺮ‬
                              ‫داﻟﺔ اﺧﺮى ﺗﻌﻮد ﺑﺒﺎﻗﻲ اﻟﻘﺴﻤﺔ ﻟﻼﻋﺪاد ﻏﻴﺮ ‪:Long‬‬

‫‪Function ModEx (dN As Double, dD As Double) As Double‬‬
       ‫‪ModEx = dN – Int(dN / dD) * dD‬‬
‫‪End Function‬‬

‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﻌﺎﻣﻼت اﻟﻤﻨﻄﻘﻴﺔ، ﻓﻴﻮﻓﺮ ‪ Visual Basic‬ﺳﺖ ﻣﻌـﺎﻣﻼت ﻣﻨﻄﻘﻴـﺔ هـﻲ =،‬
   ‫ـ‬                  ‫ـ ـ‬          ‫ـ‬       ‫ـ‬         ‫ـ‬
‫<، =<، >، => و ><. ﺑﺎﻟﻨﺴ ـﺒﺔ ﻟﻤﻌﺎﻣ ـﻞ اﻟﻤﺴ ـﺎواة = ﻓﻬ ـﻮ ﻟ ـﻴﺲ آﻤﻌﺎﻣ ـﻞ اﺳ ـﻨﺎد‬
‫اﻟﻘﻴﻢ اﻟﻰ اﻟﻤﺘﻐﻴﺮات، ﻓﻤﻌﺎﻣﻞ اﻟﻤﺴﺎواة = هـﻮ اﻟﻤﻌﺎﻣـﻞ اﻟـﺬي ﻳﻄﺒﻘـﻪ ‪Visual Basic‬‬
     ‫ﻓﻲ داﺧﻞ اﻟﺠﻤﻞ اﻟﺸﺮﻃﻴﺔ او ﺣﺘﻰ اذا ﺳﺒﻘﻪ ﻣﻌﺎﻣﻞ اﺳﻨﺎد ﺁﺧﺮ، ﻓﺎﻟﻜﻮد اﻟﺘﺎﻟﻲ:‬

‫‪Dim X As Integer, Y As Integer‬‬
‫01 = ‪X = Y‬‬

‫ﻳﺒــﻴﻦ ﻟﻨــﺎ ان اﻟﻤﻌﺎﻣــﻞ = اﻟﺜــﺎﻧﻲ اﻟﻤﻮﺟــﻮد ﻓــﻲ اﻟﺴــﻄﺮ اﻟﺜــﺎﻧﻲ هــﻮ ﻣﻌﺎﻣ ـﻞ ﻣﻘﺎرﻧــﺔ‬
                                                       ‫اﻟﻤﺴﺎواة وﻟﻴﺲ اﺳﻨﺎد اﻟﻘﻴﻢ.‬

 ‫ﺗﻔﺮق ﻣﻌﻈﻢ ﻟﻐﺎت اﻟﺒﺮﻣﺠـﺔ اﻻﺧـﺮى ﺑـﻴﻦ ﻣﻌﺎﻣـﻞ اﻟﻤﺴـﺎواة وﻣﻌﺎﻣـﻞ‬                ‫ﻣﻼﺣﻈﺔ:‬
 ‫اﺳﻨﺎد اﻟﻘﻴﻢ، ﻓﻨﺠﺪ ﻓﻲ ﻟﻐﺔ اﻟـ ‪ C‬ﻣﻌﺎﻣﻞ اﻟﻤﺴـﺎواة هـﻮ == وﻣﻌﺎﻣـﻞ‬
                                             ‫اﺳﻨﺎد اﻟﻘﻴﻢ هﻮ =.‬
                                             ‫611‬


‫اﻣﺎ ﻣﻌﺎﻣﻼت اﻟـﺮﺑﻂ ‪ XOR ،AND‬و ‪ NOT‬ﻓﻬـﻲ ﻣﺪﻋﻮﻣـﺔ اﻳﻀـﺎ ﻟـﺮﺑﻂ اﻟﺠﻤـﻞ اﻟﻤﻨﻄﻘﻴـﺔ‬
‫وﻳﻤﻜﻨﻚ اﺳﺘﺨﺪاﻣﻬﺎ ﻟﻼﻋﺪاد ﺣﻴـﺚ ﺗـﺆﺛﺮ ﻋﻠـﻰ اﻟﺒﺘـﺎت ‪ Bits‬اﻟﺘـﻲ ﺗﻤﺜـﻞ ﻗﻴﻤـﺔ اﻟﻌـﺪد‬
                                                          ‫ﺑﺎﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ ‪.Binary‬‬

                                                        ‫اﺳﺒﻘﻴﺔ اﻟﻤﻌﺎﻣﻼت:‬
‫ﻣﻦ اﻟﻤﻔﻴﺪ ان اذآﺮ هﻨﺎ، ان ﻣﻦ اﻻﺧﻄﺎء اﻟﺸﺎﺋﻌﺔ اﻟﺘﻲ ﻳﻘﻊ ﻓﻴﻬﺎ اﻏﻠﺐ اﻟﻤﺒﺮﻣﺠﻴﻦ هﻮ‬
‫ﻧﺴﻴﺎن ان اﺳﺒﻘﻴﺔ اﻟﻤﻌﺎﻣﻞ ‪ And‬اﻋﻠﻰ ﻣﻦ اﻟﻤﻌﺎﻣﻞ ‪ ،Or‬ﻓﻤﻘﺎرﻧﺔ اﻟﻤﻌﺎﻣـﻞ ‪ And‬ﺗـﺘﻢ‬
 ‫ـ‬       ‫ـ‬        ‫ـ‬     ‫ـ‬
‫ﻗﺒـﻞ ﻣﻘﺎرﻧـﺔ اﻟﻤﻌﺎﻣـﻞ ‪ Or‬ﺣﺘـﻰ وﻟـﻮ آـﺎن اﻟﻤﻌﺎﻣـﻞ ‪ Or‬هـﻮ اﻟﺴـﺎﺑﻖ اي ﻓـﻲ اﻟﺠﻬـﺔ‬
                                ‫ـ‬        ‫ـ ـ‬     ‫ـ‬       ‫ـ‬        ‫ـ‬
                                   ‫اﻟﻴﺴﺮى ﻗﺒﻞ اﻟﻤﻌﺎﻣﻞ ‪،And‬ﻓﻔﻲ هﺬا اﻟﻤﺜﺎل:‬

‫‪Print True Or False And False‬‬

‫ﻟﻠﻮهﻠﺔ اﻻوﻟﻰ ﻳﻌﺘﻘﺪ اﻟﻤﺒﺮﻣﺞ ان اﻟﻨﺘﻴﺠـﺔ هـﻲ ‪ False‬ﺑﻴﻨﻤـﺎ اﻟﻨﺘﻴﺠـﺔ اﻟﺤﻘﻴﻘﻴـﺔ هـﻲ‬
‫‪ True‬وذﻟﻚ، ﻻن اﻟﻤﻌﺎﻣﻞ اﻟﺸـﺮﻃﻲ ‪ And‬ﻳـﺘﻢ اﺧﺘﺒـﺎرﻩ ﻗﺒـﻞ اﻟﻤﻌﺎﻣـﻞ اﻟﺸـﺮﻃﻲ ‪.Or‬‬
                                                 ‫وﻟﺘﺠﻨﺐ ذﻟﻚ، اﺳﺘﺨﺪم اﻻﻗﻮاس:‬

‫‪Print (True Or False) And False‬‬

‫اﻟﻤﺰﻳﺪ اﻳﻀﺎ، اﺳﺒﻘﻴﺔ اﻟﻤﻌﺎﻣﻞ ‪ Not‬اﻋﻠﻰ ﻣﻦ اﺳـﺒﻘﻴﺔ اﻟﻤﻌﺎﻣـﻞ ‪ And‬اي ﻳـﺘﻢ ﺗﻨﻔﻴـﺬﻩ‬
                                              ‫داﺋﻤﺎ ﻗﺒﻞ ﻣﻌﺎﻣﻞ ‪ And‬ﻓﺎﻟﻌﺒﺎرة :‬

‫‪Print Not True And False‬‬

‫ﺳﺘﻘﻮم ﺑﺘﻨﻔﻴﺬ اﻟﻤﻌﺎﻣﻞ ‪ Not‬ﻋﻠﻰ آﻠﻤﺔ ‪ True‬اﻻوﻟﻰ ﻓﻘـﻂ ﺣﺘـﻰ ﺗﻜـﻮن ‪False And‬‬
‫‪ False‬وﺑﻌﺪ ذﻟﻚ ﻳﺄﺗﻲ دور اﻟﻤﻌﺎﻣﻞ ‪ And‬وآﻤﺎ هﻮ واﺿﺢ ﻓﻨﺘﻴﺠـﺔ اﻟﺘﻌﺒﻴـﺮ هـﻲ ‪.False‬‬
     ‫ـ‬           ‫ـ‬       ‫ـ‬        ‫ـ‬       ‫ـ‬         ‫ـ‬       ‫ـ‬
‫اﻣـﺎ اذا اردت ﺗﻨﻔﻴـﺬ اﻟﻤﻌﺎﻣـﻞ ‪ And‬وﻣـﻦ ﺛـﻢ ﻋﻜـﺲ اﻟﻨﺘﻴﺠـﺔ ﻓﺘﺴـﺘﻄﻴﻊ ان ﺗﺴـﺘﺨﺪم‬
                   ‫اﻻﻗﻮاس واﻟﺘﻲ ﻟﻬﺎ اﻷﺳﺒﻘﻴﺔ اﻷوﻟﻰ ﻋﻠﻰ ﺟﻤﻴﻊ اﻟﻤﻌﺎﻣﻼت ﻣﺜﻞ:‬

‫)‪Print Not (True And False‬‬

                                  ‫وﻓﻲ هﺬﻩ اﻟﺤﺎﻟﺔ، ﺳﻴﻜﻮن اﻟﻨﺎﺗﺞ اﻟﻨﻬﺎﺋﻲ هﻮ ‪.True‬‬
                                                   ‫711‬


                                                                    ‫اﻟﺪوال اﻟﺮﻳﺎﺿﻴﺔ‬
‫ﻣﻦ اﻟﺪوال اﻟﺮﻳﺎﺿﻴﺔ اﻟﺘﻲ ﻳﻮﻓﺮهﺎ ﻟﻚ ‪ Visual Basic‬داﻟـﺔ اﻟﻘﻴﻤـﺔ اﻟﻤﻄﻠﻘـﺔ ‪ Abs‬وداﻟـﺔ‬
‫اﻟﺠﺬر اﻟﺘﺮﺑﻴﻌﻲ ‪ Sqr‬واﻟﺪاﻟﺔ اﻻﺳﻴﺔ ‪ ،Exp‬اﻣﺎ اﻟﺪاﻟﺔ ‪ Sgn‬ﻓﻬﻲ ﺗﻌﻮد ﺑـﺎﻟﻘﻴﻢ 1 اذا آـﺎن‬
‫اﻟﻌﺪد اﻟﻤﺮﺳﻞ ﻟﻬﺎ ﻣﻮﺟﺐ، واﻟﻘﻴﻤﺔ -1 اذا آﺎن اﻟﻌﺪد اﻟﻤﺮﺳـﻞ ﻟﻬـﺎ ﺳـﺎﻟﺐ، وﺻـﻔﺮ اذا‬
                                                           ‫آﺎن اﻟﻌﺪد اﻟﻤﺮﺳﻞ ﺻﻔﺮ.‬
‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﺪاﻟـﺔ اﻟﻠﻮﻏـﺎرﺛﻢ ‪ Log‬ﻓﻬـﻲ ﺗﻌـﻮد ﺑﺎﻟﻠﻮﻏـﺎرﺛﻢ اﻟﻄﺒﻴﻌـﻲ ﻟﻠﻌـﺪد، اﻣـﺎ ﻟﻼﻋـﺪاد‬
                                               ‫اﻻﺧﺮى، ﻓﺘﺴﺘﻄﻴﻊ ﺗﻄﻮﻳﺮ هﺬﻩ اﻟﺪاﻟﺔ:‬

‫‪Function LogEx (dN As Double, dBase As Double ) As Double‬‬
       ‫) ‪LogEx = Log ( dN ) / Log ( dBase‬‬
‫‪End Function‬‬

‫اﻟﻜﻮد اﻟﺴﺎﺑﻖ ﻳﺬآﺮﻧﻲ ﺑﺘﻄﻮﻳﺮ داﻟﺔ اﻟﺠـﺬر اﻟﺘﺮﺑﻴﻌـﻲ ‪ Sqr‬اﻳﻀـﺎ، ﺣﻴـﺚ ﻳﻤﻜـﻦ ان ﺗﻌـﻮد‬
                                                             ‫ﺑﺎﻟﺠﺬر اﻟﻨﻮﻧﻲ ﻟﻠﻌﺪد:‬

‫‪Function NthSqr (iNum As Integer, iRoot As Integer) As Double‬‬
  ‫)‪NthSqr = iNum ^ (1 / iRoot‬‬
‫‪End Function‬‬

‫ﻣﺜﺎل اﻟﺤﺼﻮل ﻋﻠﻰ اﻟﺠﺬر اﻟﺘﻜﻌﻴﺒﻲ '‬
‫ﻟﻌﺪد 8 '‬
‫ﺗﻌﻮد ﺑﺎﻟﻌﺪد 2 ' )3 ,8 (‪Print NthSqr‬‬

‫اﺧﻴﺮا اﻟﺪوال اﻟﻤﺜﻠﺜﻴـﺔ ‪ Tan ،Cos ،Sin‬و ‪ Atn‬اﻟﺘـﻲ ﺗﻌـﻮد ﺑﺎﻟﻘﻴﻤـﺔ اﻟﻤﻨﺎﺳـﺒﺔ اﺳـﺘﻨﺎدا‬
‫اﻟــﻰ اﻟﺰاوﻳــﺔ اﻟﻤﺮﺳــﻠﺔ ﻟﻬــﺎ ﺑﺎﻟﺮادﻳــﺎن، اﻣــﺎ ﺑﺎﻟﻨﺴــﺒﺔ ﻟﻠــﺪوال اﻟﻤﺜﻠﺜﻴــﺔ اﻻﺧــﺮى ‪،Sec‬‬
‫‪ .... ،Cosec‬اﻟﺦ ﻓﻴﻤﻜﻨﻚ اﺷﺘﻘﺎﻗﻬﺎ ﺑﺘﻄﺒﻴﻘـﺎت ﻣﻌﺎدﻻﺗﻬـﺎ اﻟﻤﻌﺮوﻓـﺔ، هـﺬﻩ واﺣـﺪة ﻣـﻦ‬
                                                                     ‫ﻋﻨﺪي، واﻟﺒﻘﻴﺔ ﻋﻠﻴﻚ:‬

‫‪Function Sec (X As Double) As Double‬‬
       ‫)‪Sec(X) = 1 / Cos(X‬‬
‫‪End Function‬‬
                                          ‫811‬


                                                        ‫ﺗﻨﺴﻴﻖ اﻻﻋﺪاد‬
‫ﻣﻦ اﻗﻮى دوال اﻟﺘﻨﺴﻴﻖ هﻲ داﻟﺔ ‪ Format‬اﻟﺘﻲ ﺗﻮﻓﺮ ﻟﻚ ﺧﻴﺎرات ﻻ ﻧﻬﺎﺋﻴـﺔ ﻟﺘﻨﺴـﻴﻖ‬
‫اﻻﻋﺪاد، اﻟﺤﺮوف، اﻟﻮﻗﺖ واﻟﺘﺎرﻳﺦ اﻳﻀﺎ، ﺳﺎﺳﺮد ﻟﻚ ﻓـﻲ هـﺬﻩ اﻟﻔﻘـﺮة ﻃـﺮق ﺗﻨﺴـﻴﻖ‬
                                                                ‫اﻻﻋﺪاد ﻓﻘﻂ.‬
    ‫اﻟﺼﻴﻐﺔ اﻟﻤﺒﺴﻄﺔ ﻟﻠﺪاﻟﺔ ‪ Format‬ﺗﺘﻄﻠﺐ اﻟﻌﺒﺎرة -او اﻟﻘﻴﻤﺔ- و ﻃﺮﻳﻘﺔ اﻟﺘﻨﺴﻴﻖ:‬

‫) ﻃﺮﻳﻘﺔ اﻟﺘﻨﺴﻴﻖ ,اﻟﻘﻴﻤﺔ ( ‪Format‬‬

‫ﻳﻮﺟﺪ ﻧﻮﻋﺎن ﻣﻦ ﻃﺮق اﻟﺘﻨﺴﻴﻖ. اﻟﻨـﻮع اﻻول هـﻮ اﻟﺘﻨﺴـﻴﻘﺎت اﻟﻘﻴﺎﺳـﻴﺔ واﻟﺜـﺎﻧﻲ هـﻮ‬
‫اﻟﺘﻨﺴﻴﻘﺎت اﻟﺨﺎﺻﺔ. اﻟﺘﻨﺴﻴﻘﺎت اﻟﻘﻴﺎﺳﻴﺔ ﻋﺒﺎرة ﻋﻦ ﻗﻴﻢ ﻧﺤﺪد ﻧﻮع ﺗﻨﺴﻴﻖ اﻻرﻗﺎم آـ‬
‫‪ General Number‬ﻟﺘﻨﺴﻴﻖ اﻟـﺮﻗﻢ ﺑﺸـﻜﻞ ﻋـﺎم او ‪ Currency‬ﻟﺘﻨﺴـﻴﻖ اﻟـﺮﻗﻢ ﻋﻠـﻰ‬
                     ‫ﺷﻜﻞ ﻋﻤﻠﺔ وﻏﻴﺮهﺎ ﻣﻦ اﻟﻘﻴﻢ اﻟﺘﻲ ﺗﺠﺪهﺎ ﻓﻲ ﻣﻜﺘﺒﺔ ‪:MSDN‬‬

‫7654321 ‘‬
‫)"‪Print Format(1234567, "General Number‬‬
‫00.765,432,1 ر.س. ‘‬
‫)”‪Print Format(1234567, "Currency‬‬
‫765,432,1 ‘‬
‫)”‪Print Format(1234567, "Standard‬‬

‫اﻣﺎ اﻟﺘﻨﺴﻴﻘﺎت اﻟﺨﺎﺻﺔ ﻓﻬﻲ ﺗﻨﺴﻴﻘﺎت ﺗﺤﺪدهﺎ ﺑﻨﻔﺴﻚ. واﻟﺘﻲ ﺗﺴﺘﺨﺪم ﻋﻼﻣﺎت آــ‬
                           ‫#، %، 0 .... اﻟﺦ، ﺗﺠﺪهﺎ اﻳﻀﺎ ﻓﻲ ﻣﻜﺘﺒﺔ ‪:MSDN‬‬

‫75.432 ,1 '‬
‫)"00.##,#" ,765.4321(‪Print Format‬‬
‫%4.32 '‬
‫)"%#.#" ,432.0(‪Print Format‬‬
‫0.020 '‬
‫)"00.#00" ,02(‪Print Format‬‬


                                                             ‫دوال اﺧﺮى‬
‫ﻣﻦ دوال ﺣﺬف اﻟﻔﻮاﺻﻞ اﻟﺪاﻟﺘﻴﻦ ‪ Int‬و ‪ ،Fix‬اﻻوﻟﻰ ﺗﺤﺬف اﻟﻔﺎﺻﻠﺔ وﺗﺤﻮل اﻟﻌﺪد اﻟـﻰ‬
     ‫ﻋﺪد ﺻﺤﻴﺢ اﻗﻞ ﻣﻦ او ﻳﺴﺎوي اﻟﻌﺪد اﻟﻤﺮﺳﻞ ﺑﻴﻨﻤﺎ اﻟﺜﺎﻧﻴﺔ ﺗﺤﺬف اﻟﻔﺎﺻﻠﺔ ﻓﻘﻂ:‬
                                               ‫911‬



‫‪Print‬‬   ‫1 ' )2.1(‪Int‬‬
‫‪Print‬‬   ‫2- ' )2.1-(‪Int‬‬
‫‪Print‬‬   ‫1 ' )2.1(‪Fix‬‬
‫‪Print‬‬   ‫1- ' )2.1-(‪Fix‬‬

‫اﻣﺎ داﻟﺔ اﻟﺘﻘﺮﻳﺐ ‪ Round‬ﻓﻘﺪ ﻇﻬﺮت ﻓﻲ اﻻﺻﺪار 6‪ VB‬اﻟﺘﻲ ﺗﻤﻜﻨـﻚ ﻣـﻦ ﺗﺤﺪﻳـﺪ ﻋـﺪد‬
                                                        ‫اﻻرﻗﺎم اﻟﻌﺸﺮﻳﺔ:‬

‫31.2 ' )2 ,76521.2(‪Print Round‬‬

‫وﻋﻨﺪ اﻟﺤﺪﻳﺚ ﻋﻦ اﻻﻋﺪاد اﻟﺴﺘﻌﺸﺮﻳﺔ ‪ Hexadecimal‬واﻟﺜﻤﺎﻧﻴـﺔ ‪ Octal‬ﻓـﺎن اﻟـﺪاﻟﺘﻴﻦ‬
                      ‫‪ Hex‬و ‪ Oct‬ﺗﺤﻮل اﻋﺪاد اﻟﻨﻈﺎم اﻟﻌﺸﺮي اﻟﻰ اﻻﻧﻈﻤﺔ اﻟﺴﺎﺑﻘﺔ:‬

‫46 ' )001($‪Print Hex‬‬
‫441 ' )001($‪Print Oct‬‬

                 ‫وﻟﻠﺘﺤﻮﻳﻞ اﻟﻰ اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ ‪ Binary‬ﻓﻌﻠﻴﻚ ﺑﻜﺘﺎﺑﺔ اﻟﺪاﻟﺔ ‪ Bin‬ﺑﻨﻔﺴﻚ:‬

‫‪Public Function Bin(iNum As Integer) As String‬‬
  ‫‪Dim iCounter As Integer‬‬

  ‫‪Do‬‬
    ‫‪If (iNum And 2 ^ iCounter) = 2 ^ iCounter Then‬‬
       ‫‪Bin = "1" & Bin‬‬
    ‫‪Else‬‬
       ‫‪Bin = "0" & Bin‬‬
    ‫‪End If‬‬
    ‫1 + ‪iCounter = iCounter‬‬
  ‫‪Loop Until 2 ^ iCounter > iNum‬‬
‫‪End Function‬‬

‫اﻣﺎ اﻟﺪاﻟﺔ ‪ Rnd‬ﻓﻬﻲ ﺗﻌﻮد ﺑﻘﻴﻤﺔ ﻋﺸﻮاﺋﻴﺔ اﺻـﻐﺮ ﻣـﻦ 1 واآﺒـﺮ ﻣـﻦ او ﺗﺴـﺎوي ﺻـﻔﺮ،‬
              ‫ﺗﺴﺘﻄﻴﻊ ﺗﺨﺼﻴﺺ ﻣﺠﺎل ﻣﻌﻴﻦ ﻣﻦ اﻻﻋﺪاد ﺑﺎﺳﺘﺨﺪام هﺬﻩ اﻟﻤﻌﺎدﻟﺔ:‬

‫)اﺻﻐﺮ ﻗﻴﻤﺔ + ‪ + 1) * Rnd‬اﺻﻐﺮ ﻗﻴﻤﺔ – اﻋﻠﻰ ﻗﻴﻤﺔ(( ‪Int‬‬
                                                ‫021‬


               ‫ﻓﻠﻠﺤﺼﻮل ﻋﻠﻰ اﻋﺪاد ﻋﺸﻮاﺋﻴﺔ ﻓﻲ اﻟﻤﺠﺎل ]-2، 4[ اآﺘﺐ ﺷﻴﺌﺎ ﻣﺜﻞ:‬

‫)2- + ‪Print Int(7 * Rnd‬‬

‫اﺧﻴﺮا، دوال ﺗﺤﻮﻳﻞ اﻟﻘﻴﻢ اﻟﻰ اﻋﺪاد ﻟﻌﻞ اﺷﻬﺮهﺎ ‪ ،Val‬ﻟﻜﻦ اﻟﻤﻔﻀـﻞ اﺳـﺘﺨﺪام دوال‬
‫اﻟﺘﺤﻮﻳــﻞ اﻟﺘــﻲ ﺗﻤﻜﻨــﻚ ﻣــﻦ ﺗﺤﺪﻳــﺪ ﻧــﻮع اﻟﻘﻴﻤــﺔ آـــ ‪ CInt‬ﻟﻼﻋــﺪاد ‪ Integer‬و ‪CLng‬‬
                                      ‫ﻟﻼﻋﺪاد ‪ CDbl ،Long‬ﻟﻼﻋﺪاد ‪ .... Double‬اﻟﺦ.‬


                                                              ‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺤﺮوف‬
‫ﻣﻦ ﻣﻨﺎ ﻻ ﻳﺴﺘﺨﺪم اﻟﺤﺮوف؟ ﺗﻮﻓﺮ ﻟﻚ ﻣﻜﺘﺒـﺎت ‪ VB‬و ‪ VBA‬ﻋﺸـﺮات اﻟـﺪوال اﻟﻤﺨﺘﺼـﺔ‬
‫ﻓﻲ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺘﻐﻴﺮات واﻟﺜﻮاﺑﺖ اﻟﺤﺮﻓﻴﺔ ‪ .Strings‬اﻋﺮض ﻋﻠﻴﻚ ﻓـﻲ هـﺬﻩ اﻟﻔﻜـﺮة‬
‫ﻣﻌﻈﻢ هﺬﻩ اﻟﺪوال ﺑﺎﻻﺿﺎﻓﺔ اﻟﻰ ﺗﻄﺒﻴﻖ ﻓﻜﺮة اﻟﺒﺤﺚ واﻻﺳﺘﺒﺪال ‪Find and Replace‬‬
                                            ‫وﻟﻜﻨﻲ ﺳﺄﺑﺪأ ﺑﺎﻟﻤﻌﺎﻣﻼت اﻟﺤﺮﻓﻴﺔ.‬

                                                           ‫اﻟﻤﻌﺎﻣﻼت اﻟﺤﺮﻓﻴﺔ‬
                     ‫اﻟﺮﻣﺰ & ﻳﻤﺜﻞ ﻣﻌﺎﻣﻞ اﻟﺪﻣﺞ ‪ Combine Operator‬ﻟﻠﻘﻴﻢ اﻟﺤﺮﻓﻴﺔ:‬

‫‪Dim sMyName As String‬‬

‫”ﺗﺮآﻲ“ = ‪sMyName‬‬
‫”اﻟﻌﺴﻴﺮي “ & ‪sMyName = sMyName‬‬
‫‪Print sMyName‬‬    ‫”ﺗﺮآﻲ اﻟﻌﺴﻴﺮي“ ‘‬

‫اﻣﺎ ﻣﻌﺎﻣﻞ اﻟﺠﻤـﻊ "+" ﻓﺄﻧـﺎ ﻻ اﺣﺒـﺬ اﺳـﺘﺨﺪاﻣﻪ آﺜﻴـﺮا، ﻓـﺎذا آـﺎن ﻧـﻮع اﻟﻘـﻴﻢ ﺣﺮﻓﻴـﺔ‬
‫ﻓﺴﻴﺘﺤﻮل اﻟﻰ ﻣﻌﺎﻣﻞ اﻟﺠﻤﻊ "&"،واذا آﺎﻧﺖ اﺣﺪى اﻟﻘﻴﻢ ﻋﺪدﻳﺔ واﻟﺜﺎﻧﻴﺔ ﺣﺮﻓﻴﺔ ﻗﺎﺑﻠﺔ‬
                         ‫ـ‬                                 ‫ـ‬                   ‫ـ‬
‫ﻟﻠﺘﺤﻮﻳ ـﻞ اﻟــﻰ ﻋﺪدﻳــﺔ ﻓﺴ ـﻴﻜﻮن ﻣﻌﺎﻣــﻞ ﺟﻤــﻊ، اﻣــﺎ اذا آﺎﻧ ـﺖ اﺣــﺪى اﻟﻘــﻴﻢ ﻋﺪدﻳــﺔ‬
‫واﻻﺧﺮى ﺣﺮﻓﻴﺔ ﻻﻳﻤﻜﻦ ﺗﺤﻮﻳﻠﻬﺎ اﻟﻰ ﻋﺪدﻳﺔ، ﻓﺎن رﺳﺎﻟﺔ اﻟﺨﻄﺄ ‪ Type Mismatch‬ﻟﻬـﺎ‬
                                                                     ‫ﻧﺼﻴﺐ ﻣﻦ اﻟﻈﻬﻮر:‬

‫”03“ + ”02“ ‪Print‬‬      ‫”0302“ ‘‬
‫03 + ”02“ ‪Print‬‬        ‫05 ‘‬
‫001 + ”‪Print “X‬‬        ‫رﺳﺎﻟﺔ ﺧﻄﺄ ‘‬
                                                ‫121‬


‫ﺑﺎﻟﻨﺴــﺒﺔ ﻟﻠﻤﻌــﺎﻣﻼت اﻟﻤﻨﻄﻘﻴــﺔ <، ><، = .... اﻟــﺦ ﻓــﻴﻤﻜﻦ ﺗﻄﺒﻴﻘﻬــﺎ ﻋﻠــﻰ اﻟﻘــﻴﻢ‬
              ‫ـ‬      ‫ـ ـ‬   ‫ـ‬            ‫ـ‬
‫اﻟﺤﺮﻓﻴـﺔ اﻳﻀـﺎ، ﺣﻴـﺚ ﺗﻜـﻮن ﻗﻴﻤـﺔ اﻟﺤ ـﺮوف هـﻲ اﻟﻤﻘﺎﺑـﻞ ﻟﻬـﺎ ﻓـﻲ ﺟ ـﺪول ‪ ASCII‬او‬
                                               ‫ـ‬    ‫ـ‬      ‫ـ‬    ‫ـ‬     ‫ـ‬     ‫ـ‬
                                                                        ‫‪:UNICODE‬‬

‫‪Print‬‬   ‫"‪"Turki" > "TURKI‬‬      ‫‘‬   ‫‪True‬‬
‫‪Print‬‬   ‫"‪"Turki" < "TURKI‬‬      ‫‘‬   ‫‪False‬‬
‫‪Print‬‬   ‫"‪"Turki" = "TURKI‬‬      ‫‘‬   ‫‪False‬‬
‫‪Print‬‬   ‫"ﺗﺮآﻲ" > "اﺣﻤﺪ"‬        ‫‘‬   ‫‪False‬‬
‫‪Print‬‬   ‫"ﺗﺮآﻲ" < "اﺣﻤﺪ"‬        ‫‘‬   ‫‪True‬‬
‫‪Print‬‬   ‫"ﺗﺮآﻲ" = "اﺣﻤﺪ"‬        ‫‘‬   ‫‪False‬‬

 ‫ﺗﺴــﺘﻄﻴﻊ ان ﺗﺠﻌــﻞ ‪ Visual Basic‬ﻳﺘﺠﺎهــﻞ ﻣﻘﺎرﻧــﺔ ﺷــﻜﻞ اﻟﺤــﺮوف‬          ‫ﻣﻼﺣﻈﺔ:‬
  ‫ـ‬          ‫ـ‬       ‫ـ‬
 ‫اﻟﻜﺒﻴ ـﺮة واﻟﺼ ـﻐﻴﺮة ﻋﻨ ـﺪ اﺳ ـﺘﺨﺪام ﻣﻌﺎﻣ ـﻞ اﻟﻤﺴ ـﺎواة ﺷ ـﺮﻳﻄﺔ آﺘﺎﺑ ـﺔ‬
                             ‫ـ‬           ‫ـ‬     ‫ـ‬         ‫ـ‬       ‫ـ‬
     ‫ـ‬        ‫ـ‬                                        ‫ـ‬
 ‫اﻟﻜﻠﻤـﺔ اﻟﻤﺤﺠـﻮزة ‪ Option Compare Text‬ﻓـﻲ ﻣﻨﻄﻘـﺔ اﻻﻋﻼﻧـﺎت‬
                                            ‫اﻟﻌﺎﻣﺔ ﻟﻜﻞ وﺣﺪة ﺑﺮﻣﺠﻴﺔ.‬

‫اﺣﻴﺎﻧﺎ ﺗﻮد ﺗﺠﺎهـﻞ اﻟﺪﻗـﺔ اﻟﺘـﻲ ﻳﻔﺮﺿـﻬﺎ ﻋﻠﻴـﻚ ﻣﻌﺎﻣـﻞ اﻟﻤﺴـﺎواة وﺗﺴـﺘﺨﺪم ﻣﻌﺎﻣـﻞ‬
‫اﻟﺘﺸﺎﺑﻪ ‪ Like‬اﻟﺬي ﻳﺘﻴﺢ ﻟﻚ اﺳﺘﻌﻤﺎل اﻟﺤـﺮوف اﻟﺘﻌﻮﻳﻀـﻴﺔ، ﻓﻴﻤﺜـﻞ اﻟﺮﻣـﺰ # أي رﻗـﻢ‬
                    ‫واﻟﺮﻣﺰ ؟ أي ﺣﺮف، واﻟﺮﻣﺰ * أي ﻋﺪد ﻣﻌﻴﻦ ﻣﻦ اﻟﺤﺮوف واﻻرﻗﺎم:‬

‫‪Dim sMyString As String‬‬

‫… = ‪sMyString‬‬

‫… ‪If sMyString Like “A????” Then‬‬ ‫”4321‪ “A‬او ”‪‘ “Abcde‬‬
‫… ‪If sMyString Like “A*” Then‬‬    ‫”4321‪ “Aabce‬او ”‪‘ “Ab‬‬
‫”4321‪ “A‬او ”0000‪If sMyString Like “A####” Then … ‘ “A‬‬

              ‫او ﺑﺎﻣﻜﺎﻧﻚ ﺗﺤﺪﻳﺪ ﺣﺮوف ﻣﻌﻴﻨﺔ او ﻣﺠﺎل ﻣﻌﻴﻦ ﺑﺎﺳﺘﺨﺪام اﻻﻗﻮاس ] و [:‬

‫‪Dim sMyString As String‬‬

‫… = ‪sMyString‬‬

‫”4321‪ “B‬او ”4321‪If sMyString Like “[AB]###” Then … ‘ “A‬‬
                                                ‫221‬


‫”‪ “BY‬او ”‪If sMyString Like “[AB][XY]” Then … ‘ “AX‬‬
‫”3‪ “D‬او ”9‪If sMyString Like “[A-D]#” Then … ‘ “C‬‬

               ‫وﺣﺘﻰ ﻳﻤﻜﻨﻚ اﺳﺘﺜﻨﺎء ﺣﺮوف ﻣﻌﻴﻨﺔ او ﻣﺠﺎل ﻣﻌﻴﻦ ﺑﺎﺳﺘﺨﺪام اﻟﺮﻣﺰ !:‬

‫‪Dim sMyString As String‬‬

‫… = ‪sMyString‬‬

‫… ‪If sMyString Like “[!0-9]###” Then‬‬           ‫”4321‪ “Z‬او ”4321‪‘ “A‬‬


                                                            ‫اﻟﺒﺤﺚ واﻻﺳﺘﺒﺪال‬
‫ﺗﺴﺘﻄﻴﻊ اﻟﺒﺤﺚ ﻋﻦ آﻠﻤﺔ او ﺣﺮوف ﻣﻌﻴﻨﺔ داﺧﻞ ﻗﻴﻤﺔ ﺣﺮﻓﻴﺔ ﻋﻦ ﻃﺮﻳﻖ اﻟﺪاﻟﺔ ‪InStr‬‬
                                  ‫اﻟﺘﻲ ﺗﻌﻮد ﺑﻤﻮﻗﻊ ذﻟﻚ اﻟﺤﺮف او ﺑﺪاﻳﺔ اﻟﻜﻠﻤﺔ:‬

‫‪Dim lPosition As Long‬‬
‫‪Dim lStartPoint As Long‬‬

‫1 = ‪lStartPoint‬‬
‫)"ﺗﺮآﻲ" ,‪lPosition = InStr (lStartPoint, Text1.Text‬‬
‫‪If lPosition > 0 Then‬‬
    ‫1 - ‪Text1.SelStart = lPosition‬‬
    ‫4 = ‪Text1.SelLength‬‬
‫‪End If‬‬

‫اﻣــﺎ اﻟﺪاﻟــﺔ ‪ InStrRev‬ﻓﻬــﻲ ﺷــﺒﻴﻬﻪ ﺑﺎﻟﺪاﻟــﺔ اﻟﺴــﺎﺑﻘﺔ وﻟﻜــﻦ ﻋﻤﻠﻴــﺔ اﻟﺒﺤــﺚ ﺗﻜــﻮن‬
                                        ‫ﻣﻌﺎآﺴﺔ -أي ﺗﺒﺪأ ﻣﻦ ﻧﻬﺎﻳﺔ اﻟﻘﻴﻤﺔ اﻟﻤﺮﺳﻠﺔ.‬
‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻌﻤﻠﻴﺔ اﺳﺘﺒﺪال اﻟﻨﺼﻮص، ﻓﻠﻦ ﺗﺠﺪ اﺳﺮع ﻣﻦ اﻟﺪاﻟﺔ ‪ Replace‬اﻟﺘﻲ ﺗﻤﻜﻨﻚ‬
‫ﻣﻦ اﺳﺘﺒﺪال ﺣﺮوف ﻣﻌﻴﻨﺔ ﺑﺤﺮوف اﺧﺮى. هﻨﺎ ﺳﻨﺴﺘﺒﺪل ﺟﻤﻴﻊ آﻠﻤﺎت "ﻣﺤﻤﺪ" اﻟﻰ‬
                            ‫"ﻣﺤﻤﺪ ﺻﻠﻰ اﷲ ﻋﻠﻴﻪ وﺳﻠﻢ" اﻟﻤﻮﺟﻮدة ﻓﻲ أداة اﻟﻨﺺ:‬

‫)"ﻣﺤﻤﺪ ﺻﻠﻰ اﷲ ﻋﻠﻴﻪ وﺳﻠﻢ" ,"ﻣﺤﻤﺪ" ,‪Text1.Text = Replace(Text1.Text‬‬
                                              ‫321‬


                                                            ‫ﺗﻨﺴﻴﻖ اﻟﺤﺮوف‬
    ‫ـ‬      ‫ـ‬     ‫ـ‬        ‫ـ‬
‫ﺳﺘﺴ ـﺘﺨﺪم اﻟﺪاﻟ ـﺔ ‪ Format‬اﻳﻀ ـﺎ ﻟﺘﻨﺴ ـﻴﻖ اﻟﺤ ـﺮوف، وﻟﻜ ـﻦ ﻻ ﺗﻮﺟ ـﺪ ﺑﻬ ـﺎ ﺗﻨﺴ ـﻴﻘﺎت‬
                                    ‫ـ‬       ‫ـ‬       ‫ـ‬             ‫ـ‬           ‫ـ‬
‫ﻗﻴﺎﺳﻴﺔ ﻟﻠﺤﺮوف، اﻣﺎ اﻟﺘﻨﺴﻴﻘﺎت اﻟﺨﺎﺻﺔ ﻓﻬﻲ ﺗﺴﺘﺨﺪم اﻟﺮﻣﺰ @ اﻟﺬي ﻳﻤﺜﻞ ﺣﺮف او‬
                                        ‫ﻣﺴﺎﻓﺔ واﻟﺮﻣﺰ & اﻟﺬي ﻳﻤﺜﻞ ﺣﺮف او ﻻ ﺷﺊ:‬

‫)"@ @ @ @" ,"‪Print Format("ABCD‬‬           ‫”‪‘ “A B C D‬‬
‫)"&&& @" ,"‪Print Format("ABCD‬‬             ‫”‪‘ “A BCD‬‬
‫”765432-1-669“ ‘ )"@@@@@@-&-&&&" ,"7654321669"(‪Print Format‬‬


                                                                   ‫دوال اﺧﺮى‬
‫ﻣﻦ اﻟﺪوال اﻟﺤﺮﻓﻴﺔ اﻻﺧﺮى دوال اﺳﺘﺨﻼص اﻟﺤﺮوف اﻟﻴﺴﺮى $‪ ،Left‬اﻟﺤﺮوف اﻟﻴﻤﻨﻰ‬
                                        ‫$‪ Right‬و اﻟﺤﺮوف اﻟﻮﺳﻄﻰ $‪:Mid‬‬

‫‪Dim sMyString As String‬‬

‫”‪sMyString = “ABCDEFGHIJKLMNOPQRSTUVWXYZ‬‬
‫)5 ,‪Print Left$ ( sMyString‬‬    ‫‪‘ ABCDE‬‬
‫)5 ,‪Print Right$ ( sMyString‬‬   ‫‪‘ VWXYZ‬‬
‫)5 ,02 ,‪Print Mid$ ( sMyString‬‬ ‫‪‘ TUVWX‬‬
‫)02 ,‪Print Mid$ ( sMyString‬‬    ‫‪‘ TUVWXYZ‬‬

‫وﻋﻨﺪ اﻟﺤﺪﻳﺚ ﻋـﻦ ﺣـﺮوف ﻟﻐﺘﻨـﺎ اﻟﺠﻤﻴﻠـﺔ، ﻓﻤـﻦ اﻟﻤﻌـﺮوف ان اﻟـﺪاﻟﺘﻴﻦ ‪ Right‬و ‪Left‬‬
‫ﺗﻌﻄﻴﺎن ﻧﺘـﺎﺋﺞ ﻋﻜﺴـﻴﺔ ﻣـﻊ اﻟﺤـﺮوف اﻟﻌﺮﺑﻴـﺔ. ﻓﺎﻻﺳـﺘﺪﻋﺎء $‪ Right‬ﻟﻠﺠﻤﻠـﺔ "ﻣﺮﺣﺒـﺎ"‬
‫ﺳﺒﺪأ ﻣﻦ اﻻﻟﻒ ﻓﺎﻟﺒﺎء ﻓﺎﻟﺤﺎء اﻟـﺦ.. ﻣﻤـﺎ ﻳﺴـﺒﺐ اﻟﺘﺸـﻮﻳﺶ ﻋﻠـﻰ اﻟﻤﺒـﺮﻣﺞ اﻟﻌﺮﺑـﻲ.‬
‫اﻟﻔﻜﺮة ﺑﻜﻞ ﺑﺴﺎﻃﺔ ﻟﺠﻌﻞ هﺎﺗﻴﻦ اﻟﺪاﻟﺘﻴﻦ ﺗﻌﻤﻼن ﺑﺸﻜﻞ ﺻﺤﻴﺢ ﻣﻊ اﻟﺤﺮوف اﻟﻌﺮﺑﻴـﺔ،‬
                           ‫هﻲ ﻋﻦ ﻃﺮﻳﻖ ﺗﻄﻮﻳﺮ داﻟﺘﻴﻦ ﻋﺮﺑﻴﺘﻴﻦ ‪ ArRight‬و ‪:ArLeft‬‬

‫‪Function ArLeft(sString As String, lLength As Long) As String‬‬
  ‫)‪ArLeft = Right$(sString, lLength‬‬
‫‪End Function‬‬

‫‪Function ArRight(sString As String, lLength As Long) As String‬‬
  ‫)‪ArRight = Left$(sString, lLength‬‬
‫‪End Function‬‬
                                           ‫421‬


‫)(‪Private Sub Form_Click‬‬
  ‫ﻣﺜﺎل ﻟﻼﺳﺘﺪﻋﺎء '‬
  ‫ﺗﺮآﻲ ' )4 ,"ﺗﺮآﻲ اﻟﻌﺴﻴﺮي"($‪Print ArRight‬‬
  ‫اﻟﻌﺴﻴﺮي ' )7 ,"ﺗﺮآﻲ اﻟﻌﺴﻴﺮي"($‪Print ArLeft‬‬
‫‪End Sub‬‬

‫اﻋﻮد ﻟﻠﺪاﻟﺔ $‪ Mid‬ﻣﺮة اﺧﺮى، ﻓﻌﻠﻴﻚ ﻣﻌﺮﻓـﺔ ان $‪ Mid‬هـﻲ ﻋﺒـﺎرة ‪ Statement‬اﻳﻀـﺎ،‬
                                                    ‫ﻓﻴﻤﻜﻨﻚ آﺘﺎﺑﺔ ﺷﻴﺌﺎ ﻣﺜﻞ:‬

‫‪Dim sMyString As String‬‬

‫"‪sMyString = "abcde‬‬
‫"‪Mid$(sMyString, 2, 3) = "BCD‬‬
‫‪Print sMyString‬‬       ‫”‪‘ “aBCDe‬‬

‫وﺑﺪﻻ ﻣﻦ ﻣﻌﺮﻓـﺔ ﻣـﺎ اذا آـﺎن اﻟﻤﺘﻐﻴـﺮ اﻟﺤﺮﻓـﻲ ﺧﺎﻟﻴـﺎ ﺑﺎﺳـﺘﺨﺪام ﻋﻼﻣـﺎت اﻟﺘﻨﺼـﻴﺺ،‬
‫اﺳﺘﺨﺪم اﻟﺪاﻟﺔ ‪ Len‬اﻟﺘﻲ ﺗﻌﻮد ﺑﻌﺪد ﺣﺮوف اﻟﻘﻴﻤﺔ اﻟﻤﺮﺳﻠﺔ ﻓﻬﻲ اﺳﺮع ﻣـﺮﺗﻴﻦ ﻣـﻦ‬
                                                                ‫اﻟﻄﺮﻳﻘﺔ اﻻوﻟﻰ:‬

‫… ‪If sMyString = “” Then‬‬
‫هﺬﻩ اﺳﺮع ‘ … ‪If Len(sMyString) = 0 Then‬‬

‫اﻣﺎ ﻟﺤﺬف اﻟﻤﺴﺎﻓﺎت اﻟﻴﻤﻨﻰ اﺳﺘﺨﺪم اﻟﺪاﻟﺔ $‪ ،RTrim‬اﻟﻤﺴـﺎﻓﺎت اﻟﻴﺴـﺮى $‪LTrim‬‬
                                        ‫واﻟﻤﺴﺎﻓﺎت اﻟﻴﻤﻨﻰ واﻟﻴﺴﺮى $‪:Trim‬‬

‫” 54321 “ = ‪sMyString‬‬
‫)‪Print RTrim$ (sMyString‬‬      ‫”54321 “ ‘‬
‫)‪Print LTrim$ (sMyString‬‬      ‫” 54321“ ‘‬
‫)‪Print Trim$ (sMyString‬‬       ‫”54321“ ‘‬

‫اﻟﺪاﻟﺔ ‪ Asc‬ﺗﻌﻮد ﺑﺎﻟﻌﺪد اﻟﻤﻘﺎﺑﻞ ﻟﻠﺤﺮف ﻓـﻲ ﺟـﺪول ‪ ،ASCII‬اﻣـﺎ ‪ AscW‬ﻓﻬـﻲ ﻟﻠﺘﺮﻣﻴـﺰ‬
       ‫‪ ،UNICODE‬واﻟﺪوال $‪ Chr‬و $‪ ChrW‬ﺗﻌﻮد ﺑﺎﻟﺤﺮف اﻟﻤﻘﺎﺑﻞ ﻟﻠﻌﺪد –أي اﻟﻌﻜﺲ:‬

‫)"ت"(‪Print Asc‬‬       ‫202 ‘‬
‫)"ت"(‪Print AscW‬‬      ‫8751 ‘‬
‫)202($‪Print Chr‬‬      ‫ت‘‬
                                                ‫521‬


‫)8751($‪Print ChrW‬‬       ‫ت‘‬

‫ﻣﻦ اﻟﺪوال اﻻﺧﺮى داﻟﺘﻲ $‪ UCase‬و $‪ LCase‬اﻟﻠﺘﺎن ﺗﻘﻮﻣﺎن ﺑﺘﻜﺒﻴﺮ اﻟﺤﺮوف اﻻﻧﺠﻠﻴﺰﻳﺔ‬
‫وﺗﺼــﻐﻴﺮهﺎ. اﺳــﺘﺨﺪام هﺎﺗــﺎن اﻟــﺪاﻟﺘﺎن ﻣﺴــﺄﻟﺔ ﺿــﺮورﻳﺔ ﺧﺎﺻــﺔ ﻋﻨــﺪ ﻣﻘﺎرﻧــﺔ اﻟﻘــﻴﻢ‬
                                 ‫اﻟﺤﺮﻓﻴﺔ، ﻓﻼ ﺗﻨﺴﻰ ان ”‪ “Turki‬ﻻ ﺗﺴﺎوي ”‪:“TURKI‬‬

‫… ‪If Text1.Text = “TURKI” Then‬‬       ‫ﻗﺪ ﻻ ﻳﻜﺘﺐ اﻟﻤﺴﺘﺨﺪم ﺣﺮوف آﺒﻴﺮة ‘‬
‫… ‪If UCase$( Text1.Text ) = “TURKI” Then‬‬
‫… ‪If LCase$( Text1.Text ) = “turki” Then‬‬

          ‫ـ‬       ‫ـ‬                        ‫ـ‬      ‫ـ‬                ‫ـ‬            ‫ـ‬
‫اﻟﺪاﻟ ـﺔ $‪ UCase‬ﺗﻘ ـﻮم ﺑﺘﻜﺒﻴــﺮ ﺟﻤﻴ ـﻊ اﻟﺤ ـﺮوف واﻟﺪاﻟــﺔ $‪ LCase‬ﺗﻘ ـﻮم ﺑﺘﺼ ـﻐﻴﺮ ﺟﻤﻴــﻊ‬
‫اﻟﺤﺮوف آﻤﺎ رأﻳﻨﺎ ﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ، اﻣﺎ اذا آﻨﺖ ﺗﺮﻳـﺪ ﺗﻜﺒﻴـﺮ اﻟﺤـﺮف اﻻول ﻣـﻦ آـﻞ‬
                          ‫آﻠﻤﺔ، ﻓﺎرﺳﻞ اﻟﺜﺎﺑﺖ ‪ vbProperCase‬اﻟﻰ اﻟﺪاﻟﺔ ‪:StrConv‬‬

‫"‪sMyString = "I like Visual Basic‬‬
‫)‪Print StrConv(sMyString, vbProperCase‬‬         ‫”‪‘ “I Like Visual Basic‬‬
‫)‪Print StrConv(sMyString, vbLowerCase‬‬          ‫”‪‘ “i like visual basic‬‬
‫)‪Print StrConv(sMyString, vbUpperCase‬‬          ‫”‪‘ “I LIKE VISUAL BASIC‬‬

‫ﺗﻤﻜﻨﻚ اﻟﺪاﻟﺔ ‪ StrConv‬اﻳﻀﺎ ﻣﻦ ﺗﺤﻮﻳﻞ اﻟﻨﺼﻮص ﻣﻦ ‪ ASCII‬اﻟـﻰ ‪ UNICODE‬ﺑﺎرﺳـﺎل‬
 ‫اﻟﺜﺎﺑﺖ ‪ vbUnicode‬او ﻣﻦ ‪ UNICODE‬اﻟﻰ ‪ ASCII‬ﺑﺎرﺳﺎل اﻟﺜﺎﺑﺖ ‪.vbFromUnicode‬‬

 ‫ﺑﻌﺾ اﻟﺪوال اﻟﺤﺮﻓﻴﺔ ﺗﺘﻮﻓﺮ ﻣﻨﻬـﺎ ﻧﺴـﺨﺘﻴﻦ، اﻻوﻟـﻰ ﺗﻌـﻮد ﺑﻘﻴﻤـﺔ ﻣـﻦ‬           ‫ﻣﻼﺣﻈﺔ:‬
  ‫ـ‬         ‫ـ‬              ‫ـ‬     ‫ـ ـ‬        ‫ـ‬    ‫ـ‬                 ‫ـ‬
 ‫اﻟﻨـﻮع ‪ String‬واﻟﺜﺎﻧﻴـﺔ ﺗﻌـﻮد ﺑﻘﻴﻤـﺔ ﻣـﻦ اﻟﻨـﻮع ‪ .Variant‬ﺣـﺎول داﺋﻤ ـﺎ‬
 ‫اﺳﺘﺨﺪام اﻟﻨﺴﺨﺔ اﻻوﻟﻰ ﻣﻦ اﻟﺪاﻟﺔ –اذا ﺗـﻮﻓﺮت- ﻋـﻦ ﻃﺮﻳـﻖ اﺿـﺎﻓﺔ‬
 ‫اﻟﺮﻣﺰ $ ﺑﻌﺪ اﺳﻢ اﻟﺪاﻟﺔ ﻟﺘﺮﻓﻊ ﻋﺐء ﺗﺤﻮﻳﻞ ﻧﻮع اﻟﻘﻴﻤﺔ اﻟﺬي ﻳﻘﻮم ﺑـﻪ‬
                     ‫‪ Visual Basic‬ﻣﻤﺎ ﻳﺆدي اﻟﻰ زﻳﺎدة ﺳﺮﻋﺔ اﻟﺘﻨﻔﻴﺬ.‬

‫اﻟﺪاﻟﺔ ‪ Split‬ﺗﻤﻜﻨﻚ ﻣﻦ ﻓﺼﻞ ﺟﻤﻴﻊ اﻟﻜﻠﻤﺎت وﻧﺴﺦ آﻞ آﻠﻤﺔ اﻟﻰ ﻣﺼﻔﻮﻓﺔ، اﻓﺘﺮاﺿـﻴﺎ‬
                ‫اﻟﻔﺎﺻﻞ ﺑﻴﻦ اﻟﻜﻠﻤﺎت هﻲ اﻟﻤﺴﺎﻓﺔ آﻤﺎ ﻳﻤﻜﻨﻚ ﺗﺤﺪﻳﺪ ﻓﺎﺻﻞ ﻣﻌﻴﻦ:‬

‫‪Dim X() As String‬‬
‫‪Dim iCounter As Integer‬‬

‫)‪X = Split(Text1.Text‬‬
                                             ‫621‬


‫ﺗﺤﺪﻳﺪ ﻓﺎﺻﻞ ﻏﻴﺮ اﻟﻤﺴﺎﻓﺔ ‘‬
‫)"*" ,‪‘ X = Split(Text1.Text‬‬

‫)‪For iCounter = 0 To UBound(X‬‬
   ‫)‪Print X(iCounter‬‬
‫‪Next‬‬

         ‫واذا ﻧﺪﻣﺖ ﻋﻠﻰ ﺗﻘﺴﻴﻢ اﻟﻜﻠﻤﺎت، ﻓﺎﻟﺪاﻟﺔ ‪ Join‬ﺗﻌﻴﺪ اﻟﻮﺿﻊ آﻤﺎ آﺎن ﺳﺎﺑﻘﺎ:‬

‫)‪sFromArrayToString = Join (X‬‬
‫ﺗﺤﺪﻳﺪ ﻓﺎﺻﻞ ﻏﻴﺮ اﻟﻤﺴﺎﻓﺔ ‘ )“*“ ,‪‘ sFromArrayToString = Join (X‬‬

‫اﺧﻴﺮا، داﻟﺘﻲ ﺗﺤﻮﻳﻞ اﻟﻘـﻴﻢ اﻟـﻰ ﺣﺮﻓﻴـﺔ $‪ Str‬و ‪ ،CStr‬واﻟﻔـﺮق ﺑﻴﻨﻬﻤـﺎ هـﻮ ان اﻻوﻟـﻰ‬
                ‫ﺗﻀﻴﻒ ﻣﺴﺎﻓﺔ ﻳﺴﺎر اﻟﻌﺪد اﻟﻤﺮﺳﻞ ﻟﻬﺎ ان آﺎن ﻣﻮﺟﺐ ام اﻟﺜﺎﻧﻴﺔ ﻓﻼ.‬


                                              ‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻮﻗﺖ واﻟﺘﺎرﻳﺦ‬
‫ﻻ ﻗﺘﺼﺮ دﻋﻢ ‪ Visual Basic‬ﻋﻠﻰ ﻗﻴﻢ اﻟﻮﻗﺖ واﻟﺘﺎرﻳﺦ ﻓﻲ اﻣﻜﺎﻧﻴـﺔ ﺗﺼـﺮﻳﺢ ﻣﺘﻐﻴـﺮ ﻣـﻦ‬
‫اﻟﻨــﻮع ‪ ،Date‬ﺑــﻞ ﻳﺤﺘــﻮي ﻋﻠــﻰ ﻋﺸــﺮات اﻟــﺪوال اﻟﺨﺎﺻــﺔ ﺑﻌــﺮض، ﺗﻌــﺪﻳﻞ، ﺣﺴــﺎب‬
                                                     ‫وﺗﻨﺴﻴﻖ ﻗﻴﻢ اﻟﻮﻗﺖ واﻟﺘﺎرﻳﺦ.‬

                                                     ‫دوال اﻟﻮﻗﺖ واﻟﺘﺎرﻳﺦ‬
‫اﻟﻘﻴﻢ ﻣﻦ اﻟﻨﻮع ‪ Date‬هﻲ ﻗﻴﻢ ﺗﻤﺜﻞ وﻗﺖ ﻣﻌﻴﻦ او ﺗﺎرﻳﺦ ﻣﻌﻴﻦ او آﻼهﻤﺎ ﻣﻌـﺎ ﺳـﻮاء‬
                    ‫آﺎﻧﺖ ﻓﻲ ﻣﺘﻐﻴﺮ ﻣﻦ اﻟﻨﻮع ‪ Date‬او ﺛﺎﺑﺖ ﺑﻴﻦ اﻟﻌﻼﻣﺘﻴﻦ # و #:‬

‫‪Dim MyDate As Date‬‬

‫#1002/02/1# = ‪MyDate‬‬
‫‪Print MyDate‬‬
‫#‪MyDate = #2:30:00 AM‬‬
‫‪Print MyDate‬‬
‫#‪MyDate = #1/20/2001 2:30:00 AM‬‬
‫‪Print MyDate‬‬
                                              ‫721‬


‫وﻗﺒﻞ ان اﺑﺪأ ﻓـﻲ اﻟﺤـﺪﻳﺚ ﻋـﻦ دوال اﻟﻮﻗـﺖ واﻟﺘـﺎرﻳﺦ، اود ان اﻋﺮﻓـﻚ ﻋﻠـﻰ اﻟﺨﺎﺻـﻴﺔ‬
‫‪ Calendar‬اﻟﺘﺎﺑﻌﺔ ﻟﻠﻜﺎﺋﻦ ‪ VBA‬واﻟﺘﻲ ﺗﻤﻜﻨﻚ ﻣﻦ ﺗﻐﻴﻴﺮ ﻧﻈﺎم اﻟﺘـﺎرﻳﺦ اﻟﺘـﺎﺑﻊ ﻟﺒﺮﻧﺎﻣﺠـﻚ‬
                                                          ‫اﻟﻰ ﻣﻴﻼدي او هﺠﺮي:‬

‫‪Dim MyDate As Date‬‬

‫#‪MyDate = #1/20/2001 2:30:00 AM‬‬
‫هﺠﺮي ' ‪VBA.Calendar = vbCalHijri‬‬
‫‪Print MyDate‬‬
‫ﻣﻴﻼدي ' ‪VBA.Calendar = vbCalGreg‬‬
‫‪Print MyDate‬‬

‫ﻣﻊ اﻟﻌﻠﻢ ان اﻟﻘﻴﻤﺔ اﻟﺘﻲ ﺗﻀﻌﻬﺎ ﻓﻲ هﺬﻩ اﻟﺨﺎﺻﻴﺔ ﺗﺆﺛﺮ ﻋﻠﻰ ﻧﻮع اﻟﻘﻴﻤﺔ اﻟﺘـﻲ ﺗﻌـﻮد‬
                      ‫ﺑﻬﺎ دوال اﻟﺘﺎرﻳﺦ اﻻﺧﺮى وﻟﻜﻨﻬﺎ ﻻ ﺗﺆﺛﺮ ﻓﻲ ﻗﻴﻢ اﻟﻮﻗﺖ واﻟﺘﺎرﻳﺦ:‬

‫‪Dim MyDate As Date‬‬

‫‪VBA.Calendar = vbCalHijri‬‬
‫#1241/61/1# = ‪MyDate‬‬          ‫اﻟﻘﻴﻤﺔ هﻨﺎ ﺑﺎﻟﺘﺎرﻳﺦ اﻟﻤﻴﻼدي وﻟﻴﺲ اﻟﻬﺠﺮي ‘‬
‫‪Print MyDate‬‬                  ‫ﻣﺨﺮﺟﺎت اﻻﻣﺮ هﻨﺎ ﺑﺎﻟﻬﺠﺮي ‘‬

‫واﻻن اﻋﺮض ﻟﻚ دوال اﻟﻮﻗـﺖ واﻟﺘـﺎرﻳﺦ ﻣﺒﺘـﺪﺋﺎ ﺑﺎﻟـﺪاﻟﺘﻴﻦ ‪ Date‬و ‪ Time‬اﻟﻠﺘـﺎن ﺗﻌـﻮدان‬
                                                         ‫ﺑﺘﺎرﻳﺦ اﻟﻴﻮم واﻟﻮﻗﺖ اﻟﺤﺎﻟﻲ:‬

‫‪Print Date‬‬
‫‪Print Time‬‬

‫اﻣﺎ اذا ﺗﻌﺎﻣﻠـﺖ ﻣـﻊ ‪ Date‬و ‪ Time‬آﻌﺒـﺎرات ‪ ،Statement‬ﻓﻬـﻲ ﺳـﺘﻐﻴﺮ ﻗﻴﻤـﺔ اﻟﻮﻗـﺖ‬
                                                        ‫واﻟﺘﺎرﻳﺦ ﻓﻲ اﻟﻨﻈﺎم:‬

‫#1002/02/1# = ‪Date‬‬
‫#‪Time = #12:00:00 AM‬‬

                         ‫اﻟﺪاﻟﺔ ‪ Now‬ﺗﻌﻮد ﺑﻘﻴﻤﺔ ﺗﺸﻤﻞ ﺗﺎرﻳﺦ اﻟﻴﻮم واﻟﻮﻗﺖ اﻟﺤﺎﻟﻲ:‬

‫‪Print Now‬‬
                                             ‫821‬


‫اﻣﺎ اﻟﺪاﻟﺔ ‪ Timer‬ﻓﻬﻲ ﺗﻌﻮد ﺑﻌﺪد اﻟﺜﻮاﻧﻲ ﻣﻦ ﻣﻨﺘﺼﻒ اﻟﻠﻴـﻞ ﺣﺘـﻰ وﻗـﺖ اﺳـﺘﺪﻋﺎﺋﻬﺎ‬
‫أي هﻲ ﺗﻌﻤﻞ آﻌﺪاد، ﻗﺪ ﺗﺴﺘﻔﻴﺪ ﻣﻨﻬـﺎ وﺗﻄـﻮر اﺟـﺮاء اﻧﺘﻈـﺎر ﻣﺆﻗـﺖ ﻗﺒـﻞ ﺗﻨﻔﻴـﺬ آـﻮد‬
                                                                          ‫ﻣﻌﻴﻦ:‬

‫)‪Sub Wait ( iSeconds As Integer‬‬
      ‫‪Dim sStartTime As Single‬‬

      ‫‪sStartTime = Timer‬‬
      ‫‪Do: DoEvents : Loop Until Timer – sStartTime >= iSeconds‬‬
‫‪End Sub‬‬

‫ﺗﺬآﺮ ان اﻟﺪاﻟﺔ ‪ Timer‬ﻋﺒﺎرة ﻋﻦ ﻋﺪاد ﻳﺒﺪأ ﻣﻦ اﻟﺴﺎﻋﺔ 00:00:00 وﻳـﺘﻢ ﺗﺼـﻔﻴﺮﻩ ﻣـﻦ‬
‫ﺟﺪﻳﺪ ﺑﻌﺪ ﻣﺮور ﺛﺎﻧﻴﺔ ﻣﻦ اﻟﺴﺎﻋﺔ 95:95:32، ﻓﺎﻻﺟﺮاء ‪ Wait‬اﻟﺴـﺎﺑﻖ ﻗـﺪ ﻳـﺆدي اﻟـﻰ‬
‫ﺣﻠﻘﺔ ﻻ ﻧﻬﺎﺋﻴﺔ اذا ﺗﻢ ﺗﺼﻔﻴﺮ اﻟﺪاﻟﺔ ‪ Timer‬ﻗﺒﻞ ﻧﻬﺎﻳﺔ اﻟﺤﻠﻘـﺔ اﻟﻤﻮﺟـﻮدة ﻓـﻲ اﻻﺟـﺮاء.‬
‫ﺻــﺤﻴﺢ ان ﻧﺴــﺒﺔ ﺣــﺪوث اﻟﻤﺸــﻜﻠﺔ اﻟﺴــﺎﺑﻘﺔ ﺿــﺌﻴﻠﺔ، اﻻ ان ﺗﺠﻨــﺐ اﻟﺸــﻮاﺋﺐ اﻣــﺮ‬
                               ‫ﺿﺮوري، وآﻤﺎ ﻳﻘﻮﻟﻮن "اﺑﻌﺪ ﻋﻦ اﻟﺸﻮاﺋﺐ وﻏﻨﻲ ﻟﻬﺎ":‬

‫)‪Sub Wait ( iSeconds As Integer‬‬
      ‫!06 * 06 * 42 = ‪Const NUMOFSEC As Single‬‬
      ‫‪Dim sStartTime As Single‬‬
      ‫‪sStartTime = Timer‬‬
      ‫‪Do : DoEvents‬‬
      ‫‪Loop Until (Timer + NUMOFSEC – sStartTime) Mod NUMOFSEC >= iSeconds‬‬
‫‪End Sub‬‬

‫ﻟﻦ ﺗﺘﻤﻜﻦ ﻣﻦ اﺳﺘﺨﺪام اﻟﺜﺎﺑﺖ ﺑﻴﻦ اﻟﻌﻼﻣﺘـﻴﻦ # و # ﻣﺒﺎﺷـﺮة اذا آﻨـﺖ ﺗﺮﻏـﺐ ﻓـﻲ‬
‫ﺗﻌﻴﻴﻦ ﻗﻴﻢ ﻟﻤﺘﻐﻴﺮات ﺑﺎﺳﺘﺨﺪام اﻟﺘﺎرﻳﺦ اﻟﻬﺠﺮي، وﻟﻜﻦ ﻣﻊ اﻟﺪاﻟـﺔ ‪ DateSerial‬ﻳﻤﻜﻨـﻚ‬
              ‫ﻋﻤﻞ ذﻟﻚ ﻓﻬﻲ ﺗﺘﺄﺛﺮ ﺑﻘﻴﻤﺔ اﻟﺨﺎﺻﻴﺔ ‪ Calendar‬اﻟﺘﺎﺑﻌﺔ ﻟﻠﻜﺎﺋﻦ ‪:VBA‬‬

‫‪Dim MyDate As Date‬‬

‫‪VBA.Calendar = vbCalHijri‬‬
‫72 ﺷﻮال 2241 ‘ )72 ,01 ,2241(‪MyDate = DateSerial‬‬
‫‪Print MyDate‬‬
‫‪VBA.Calendar = vbCalGreg‬‬
‫ﻳﻮاﻓﻖ 11 ﻳﻨﺎﻳﺮ 2002 ‘ ‪Print MyDate‬‬
                                                ‫921‬


‫آﻤــﺎ ﺗﺘــﻮﻓﺮ داﻟــﺔ اﺧــﺮى ﻟﻠﻮﻗــﺖ هــﻲ اﻟﺪاﻟــﺔ ‪ .TimeSerial‬اﻣــﺎ ﺑﺎﻟﻨﺴــﺒﺔ ﻟﻠــﺪاﻟﺘﻴﻦ‬
‫‪ DateValue‬و ‪ TimeValue‬ﻓﻬﻤﺎ ﺗﻌﻮدان ﺑﻘﻴﻤﺔ اﻟﺘﺎرﻳﺦ او اﻟﻮﻗﺖ اﻟﻤﻮﺟﻮد ﻓـﻲ اﻟﻘﻴﻤـﺔ‬
                                                                     ‫اﻟﻤﺮﺳﻠﺔ اﻟﻴﻬﻤﺎ:‬

‫)2 + ‪Print DateValue(Now‬‬
‫)‪Print TimeValue(Now‬‬

‫ﺑﺎﻣﻜﺎﻧﻚ اﺳﺘﺨﺪام اﻟﺪاﻟﺔ ‪ DatePart‬اﻟﺘـﻲ ﺗﺴـﺘﺨﺮج ﺟـﺰء ﻣﻌـﻴﻦ ﻣـﻦ ﻗﻴﻤـﺔ اﻟﻮﻗـﺖ او‬
‫اﻟﺘﺎرﻳﺦ، وﻟﻜﻨـﻲ اﻓﻀـﻞ اﻟـﺪوال ‪ Minute ،Hour ،Year ،Month ،Day‬و ‪ Second‬ﻓﻬـﻲ‬
‫ﺗﻌﻮد ﺑﻘﻴﻤﺔ اﻟﻴﻮم، اﻟﺸﻬﺮ، اﻟﺴﻨﺔ، اﻟﺴﺎﻋﺔ، اﻟﺪﻗﻴﻘﺔ واﻟﺜﺎﻧﻴـﺔ اﻟﻤﻮﺟـﻮدة ﻓـﻲ اﻟﻘﻴﻤـﺔ‬
                                                                ‫اﻟﻤﺮﺳﻠﺔ اﻟﻴﻬﻢ:‬

‫)‪Print Month (Date‬‬
‫)#‪Print Hour (#1:20:00 AM‬‬

                                     ‫اﻟﻌﻤﻠﻴﺎت اﻟﺮﻳﺎﺿﻴﺔ ﻋﻠﻰ اﻟﻮﻗﺖ واﻟﺘﺎرﻳﺦ:‬
‫آﺜﻴﺮا ﻣﺎ ﺗﺤﺘﺎج اﻟﻰ اﺟﺮاء ﺑﻌﺾ اﻟﻌﻤﻠﻴـﺎت اﻟﺮﻳﺎﺿـﻴﺔ ﻋﻠـﻰ ﻗـﻴﻢ ﺗﺎرﻳﺨﻴـﺔ آـﺎﻟﺠﻤﻊ ﺑـﻴﻦ‬
‫ﺗﺎرﻳﺨﻴﻦ او ﻃﺮح ﺗﺎرﻳﺨﻴﻦ، ﺑﺎﻻﺿﺎﻓﺔ اﻟﻰ ﻣﻘﺎرﻧﺔ اﻟﺘﻮارﻳﺦ. ﺑﺎﻣﻜﺎﻧﻚ ﺗﻄﺒﻴﻖ ﻣﺎ ذآﺮﺗﻪ ﻓﻲ‬
‫ﻓﻘﺮة "اﻟﻨﻮع ‪ "Date‬ﻓﻲ اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ ﻻن اﻟﻘﻴﻤﺔ ﻣﻦ هﺬا اﻟﻨﻮع –آﻤﺎ ذآﺮت- ﺗﻨﻘﺴﻢ‬
‫اﻟﻰ ﻗﺴﻤﻴﻦ ﻋﺪد ﺻﺤﻴﺢ وﻋﺪد ﻋﺸﺮي، اﻟﻌﺪد اﻟﺼﺤﻴﺢ ﻳﺘﻌﻠﻖ ﺑﺎﻟﺘـﺎرﻳﺦ اﻣـﺎ اﻟﻌﺸـﺮي‬
              ‫ﻓﻬﻮ ﺧﺎص ﺑﺎﻟﻮﻗﺖ، ﺟﺮب اﺳﺘﺨﺪام ﻣﻌﺎﻣﻞ اﻟﺠﻤﻊ آﻤﺎ ﻓﻲ هﺬا اﻟﻤﺜﺎل:‬

‫اﺿﺎﻓﺔ ﻳﻮﻣﻴﻦ و 21 ﺳﺎﻋﺔ ﻣﻦ اﻻن ‘‬
‫#00:21# + 2 + ‪Print Now‬‬

‫وﻟﺘﻄﺒﻴﻖ ﻋﻤﻠﻴﺎت رﻳﺎﺿﻴﺔ اآﺜﺮ دﻗﺔ وﺳـﻬﻮﻟﺔ، ﻳﻔﻀـﻞ اﺳـﺘﺨﺪام اﻟـﺪاﻟﺘﻴﻦ ‪ DateAdd‬و‬
‫‪ ،DateDiff‬اﻻوﻟﻰ ﻻﺿـﺎﻓﺔ ﺗـﺎرﻳﺦ ﻋﻠـﻰ ﺗـﺎرﻳﺦ واﻟﺜﺎﻧﻴـﺔ ﻟﻤﻌﺮﻓـﺔ اﻟﻔـﺎرق ﺑﻴﻨﻬﻤـﺎ. داﻟـﺔ‬
                                                     ‫‪ DateAdd‬ﻟﻬﺎ ﺻﻴﻐﺔ ﻋﺎﻣﺔ هﻲ:‬

‫)اﻟﺘﺎرﻳﺦ ,اﻟﻌﺪد ,اﻟﻔﺘﺮة( ‪DateAdd‬‬

‫اﻟﻔﺘﺮة هﻲ اﻟﻮﺣـﺪة اﻟﻤﺴـﺘﺨﺪم واﻟﺘـﻲ ﻗـﺪ ﺗﻜـﻮن ﺳـﻨﺔ "‪ "yyyy‬ﺷـﻬﺮ "‪ "m‬ﻳـﻮم "‪"d‬‬
‫....اﻟﺦ، اﻣﺎ اﻟﻌﺪد ﻓﻬﻮ ﻋﺪد اﻟﻮﺣﺪات ﻣﻦ اﻟﻔﺘﺮة اﻟﺘـﻲ ﺗﺮﻳـﺪ اﺿـﺎﻓﺘﻬﺎ، اﻣـﺎ اﻟﺘـﺎرﻳﺦ ﻓﻬـﻮ‬
                                                 ‫اﻟﻘﻴﻤﺔ اﻟﺬي ﺗﺮﻳﺪ اﺿﺎﻓﺔ اﻟﺘﺎرﻳﺦ ﻋﻠﻴﻬﺎ:‬
                                               ‫031‬


‫)‪Print DateAdd ("m", 3, Now‬‬

‫اﻣﺎ ﻟﻤﻌﺮﻓﺔ اﻟﻔﺮق ﺑـﻴﻦ ﺗـﺎرﻳﺨﻴﻦ ﻓﺎﺳـﺘﺨﺪم داﻟـﺔ ‪ DateDiff‬وﺻـﻴﻐﺘﻬﺎ اﻟﻌﺎﻣـﺔ ﺷـﺒﻴﻬﻪ‬
                            ‫ﺑﺎﻻوﻟﻰ، اﻻ اﻧﻬﺎ ﺗﻄﻠﺐ ﻗﻴﻤﺔ اﻟﺘﺎرﻳﺦ ﻣﻜﺎن ﻗﻴﻤﺔ اﻟﻌﺪد:‬

‫ﻳﻮم 06 ‘ )#1002/81/2# ,#0002/02/21# ,"‪Print DateDiff("d‬‬


                                                     ‫ﺗﻨﺴﻴﻖ اﻟﻮﻗﺖ واﻟﺘﺎرﻳﺦ‬
‫ﻻ اﻋﺘﻘــﺪ اﻧﻨــﻲ ﺑﺤﺎﺟــﺔ اﻟــﻰ ﺗﻌﺮﻳﻔــﻚ ﻋﻠــﻰ اﻟﺪاﻟــﺔ ‪ Format‬ﻣــﺮة اﺧــﺮى، وﺑﺎﻟﻨﺴــﺒﺔ‬
                           ‫ﻟﻠﺘﻨﺴﻴﻘﺎت اﻟﻘﻴﺎﺳﻴﺔ ﻓﻬﻲ ﻣﺪﻋﻮﻣﺔ ﻟﻘﻴﻢ اﻟﻮﻗﺖ واﻟﺘﺎرﻳﺦ:‬

‫‪Dim sMyDate As Date‬‬

‫‪sMyDate = Now‬‬

‫‪Print‬‬   ‫)"‪Format$(sMyDate, "General Date‬‬
‫‪Print‬‬   ‫)"‪Format$(sMyDate, "Long Date‬‬
‫‪Print‬‬   ‫)"‪Format$(sMyDate, "Long Time‬‬
‫‪Print‬‬   ‫)"‪Format$(sMyDate, "HH:MM -> MMMM DD, YYYY‬‬

‫آﻤﺎ اﺿﺎف اﻻﺻﺪار 6‪ VB‬داﻟﺔ اﺿﺎﻓﻴﺔ ﻟﺘﻨﺴﻴﻖ اﻟﻮﻗﺖ واﻟﺘﺎرﻳﺦ هﻲ ‪FormatDateTime‬‬
        ‫واﻟﺪاﻟﺔ ‪ MonthName‬اﻟﺘﻲ ﺗﻌﻮد ﺑﺎﺳﻢ اﻟﺸﻬﺮ اﻟﻤﻘﺎﺑﻞ ﻟﻠﺮﻗﻢ اﻟﻤﺮﺳﻞ ﻟﻬﺎ:‬

‫‪VBA.Calendar = vbCalHijri‬‬
‫ﻣﺤﺮم ‘ )1(‪Print MonthName‬‬
‫‪VBA.Calendar = vbCalGreg‬‬
‫ﻳﻨﺎﻳﺮ ‘ )1(‪Print MonthName‬‬



                                       ‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﻠﻔﺎت واﻟﻤﺠﻠﺪات‬
‫ﻟﻢ ﻳﻀﻒ اﻻﺻﺪار 6‪ VB‬أي دوال او ﻋﺒﺎرات ﺟﺪﻳـﺪة ﻟﻠﺘﻌﺎﻣـﻞ ﻣـﻊ اﻟﻤﻠﻔـﺎت واﻟﻤﺠﻠـﺪات،‬
‫ﻓﻤﻌﻈﻢ ﻣﺎ ﺳﺄﺳﻄﺮﻩ ﻓﻲ اﻟﻔﻘـﺮات اﻟﺘﺎﻟﻴـﺔ ﺗـﻮﻓﺮ ﻣﻨـﺬ اﻻﺻـﺪارات اﻟﻘﺪﻳﻤـﺔ ﻟــ ‪Visual‬‬
‫‪ .Basic‬وﺳــﺄﺑﺪأ ﺑﻌــﺮض دوال وﻋﺒــﺎرات ﺗﻤﻜﻨــﻚ ﻣــﻦ اﻟﺘﻌﺎﻣــﻞ ﻣــﻊ اﻟﻤﻠﻔــﺎت آﺘﻌــﺪﻳﻞ‬
‫ﺧﺼﺎﺋﺼﻬﺎ، اﺳﻤﺎﺋﻬﺎ، اﻻﺳﺘﻌﻼم ﻋﻦ اﺣﺠﺎﻣﻬﺎ .... اﻟﺦ، ﺛﻢ اﺗﻄﺮق اﻟﻰ ﻋﺒـﺎرات ﺧﺎﺻـﺔ‬
                                           ‫131‬


‫ﺑﺎﻟﻤﺠﻠﺪات ‪ Folders‬وﻃﺮﻳﻘﺔ اﻟﺒﺤﺚ ﻋﻦ اﻟﻤﻠﻔﺎت واﻟﻤﺠﻠﺪات، ﺛﻢ اﺧﺘﻢ اﻟﻔﻘـﺮة ﺑﻄـﺮق‬
                                              ‫اﻟﻮﺻﻮل اﻟﻰ اﻟﻤﻠﻔﺎت وﺗﺤﺮﻳﺮهﺎ.‬

                                                    ‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﻠﻔﺎت‬
‫ﻳﻤﻜﻨﻚ اﻻﻣﺮ ‪ Name … As‬ﻣﻦ اﻋـﺎدة ﺗﺴـﻤﻴﺔ اﻟﻤﻠـﻒ او ﻧﻘﻠـﻪ، واﻻﻣـﺮ ‪ FileCopy‬ﻣـﻦ‬
                                       ‫ﻧﺴﺦ اﻟﻤﻠﻒ، ﺑﻴﻨﻤﺎ اﻻﻣﺮ ‪ Kill‬ﻳﺤﺬف اﻟﻤﻠﻒ:‬

‫اﻋﺎدة ﺗﺴﻤﻴﺔ ﻣﻠﻒ ‘‬
‫”‪Name “C:\MyFile.EXT” As “C:\MyFile.DAT‬‬
‫ﻧﻘﻞ ﻣﻠﻒ ‘‬
‫”‪Name “C:\MyFile.EXT” As “D:\MyFile.EXT‬‬
‫ﻧﺴﺦ ﻣﻠﻒ ‘‬
‫”‪FileCopy “C:\MyFile.EXT” As “D:\MyFile.EXT‬‬
‫ﻧﺴﺦ وﺗﻐﻴﻴﺮ اﺳﻢ ﻣﻠﻒ ‘‬
‫”‪FileCopy “C:\MyFile.EXT” As “C:\MyFile2.EXT‬‬
‫ﺣﺬف ﻣﻠﻒ ‘‬
‫”‪Kill “C:\MyFile.EXT‬‬
‫ﺣﺬف ﻣﺠﻤﻮﻋﺔ ﻣﻠﻔﺎت ‘‬
‫”‪Kill “*.TMP‬‬

‫ﺗﻤﻜﻨﻚ اﻟﺪاﻟﺔ ‪ GetAttr‬ﻣـﻦ ﻣﻌﺮﻓـﺔ ﺧﺼـﺎﺋﺺ اﻟﻤﻠـﻒ ‪ File Attributes‬واﻟﺪاﻟـﺔ ‪SetAttr‬‬
                                 ‫ﻟﺘﻐﻴﻴﺮ ﺧﺼﺎﺋﺺ اﻟﻤﻠﻒ –ﺷﺮﻳﻄﺔ ان ﻻ ﻳﻜﻮن ﻣﻔﺘﻮﺣﺎ:‬

‫‪Dim sFile As String‬‬

‫”‪sFile = “C:\File.EXT‬‬
‫ﻣﺨﻔﻲ ‘ … ‪If GetAttr(sFile) And vbHidden Then‬‬
‫ﻟﻠﻘﺮاءة ﻓﻘﻂ ‘ … ‪If GetAttr(sFile) And vbReadOnly Then‬‬
‫ارﺷﻴﻒ ‘ … ‪If GetAttr(sFile) And vbArchive Then‬‬
‫…‬
‫‪SetAttr sFile, vbHidden‬‬                      ‫ﻣﺨﻔﻲ ‘‬
‫‪SetAttr sFile, vbArchive + vbReadOnly‬‬        ‫ارﺷﻴﻒ وﻟﻠﻘﺮاءة ﻓﻘﻂ ‘‬
‫ﻋﻜﺲ ﺧﺎﺻﻴﺔ ﻟﻠﻘﺮاءة ﻓﻘﻂ ‘ ‪SetAttr sFile, GetAttr(sFile) Xor vbReadOnly‬‬

‫ﺗﻌﻮد اﻟﺪاﻟﺔ ‪ FileLen‬ﺑﻘﻴﻤﺔ ﺗﻤﺜﻞ ﺣﺠﻢ اﻟﻤﻠـﻒ، واﻟﺪاﻟـﺔ ‪ FileDateTime‬ﺑﻮﻗـﺖ وﺗـﺎرﻳﺦ‬
                                                                 ‫اﻧﺸﺎء اﻟﻤﻠﻒ:‬
                                               ‫231‬


‫) ‪Print FileLen ( sFile‬‬
‫) ‪Print FileDateTime ( sFile‬‬

‫اﻟﻤﻴﺰة اﻟﺘﻲ ﺗﻌﺠﺒﻨﻲ ﻓﻲ اﻟﺪاﻟﺔ ‪ FileLen‬هﻲ ﻗﺎﺑﻠﻴﺘﻬﺎ ﻋﻠـﻰ اﻟﻌـﻮدة ﺑﺤﺠـﻢ اﻟﻤﻠﻔـﺎت‬
‫ﺣﺘﻰ وان آﺎﻧﺖ ﻣﻔﺘﻮﺣﺔ، واﻟﻌﻴﺐ اﻟﺬي ﻻ ﻳﻌﺠﺒﻨـﻲ ﻓـﻲ ﻧﻔـﺲ اﻟﺪاﻟـﺔ هـﻮ ان اﻟﻘﻴﻤـﺔ‬
‫اﻟﺘﻲ ﺗﻌﻮد ﺑﻬﺎ هﻲ ﺣﺠﻢ اﻟﻤﻠﻒ ﻗﺒﻞ اﻟﻔﺘﺢ -أي ﻟـﻦ ﺗﻌـﻮد ﺑﻘﻴﻤـﺔ ﺻـﺤﻴﺤﺔ ﻓـﻲ ﺣـﺎل‬
                                              ‫ﻗﻴﺎم اﻟﺒﺮﻧﺎﻣﺞ ﺑﺘﻐﻴﻴﺮ ﺣﺠﻢ اﻟﻤﻠﻒ.‬

                                                      ‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺠﻠﺪات‬
‫ﺗﻌﻮد اﻟﺪاﻟـﺔ $‪ CurDir‬ﺑﻘﻴﻤـﺔ ﺣﺮﻓﻴـﺔ ﺗﻤﺜـﻞ اﻟـﺪﻟﻴﻞ اﻟﺤـﺎﻟﻲ ﻟﻠﻘـﺮص اﻟـﺬي ﻳﻨﻔـﺬ ﻣﻨـﻪ‬
                                 ‫اﻟﺒﺮﻧﺎﻣﺞ او ﻣﺤﺮك اﻗﺮاص ﺁﺧﺮ ﺗﺮﺳﻠﻪ اﻟﻰ اﻟﺪاﻟﺔ:‬

‫$‪Print CurDir‬‬          ‫اﻟﺪﻟﻴﻞ اﻟﺤﺎﻟﻲ ﻓﻲ اﻟﻘﺮص اﻟﺤﺎﻟﻲ ‘‬
‫)”‪Print CurDir$ (“d‬‬    ‫اﻟﺪﻟﻴﻞ اﻟﺤﺎﻟﻲ ﻓﻲ اﻟﻘﺮص :‪‘ D‬‬

                         ‫ـ‬         ‫ـ‬                ‫ـ ـ‬             ‫ـ‬
‫وﻗـﺪ ﺗﺮﻏـﺐ ﻓـﻲ ﺗﻐﻴﻴـﺮ اﻟـﺪﻟﻴﻞ اﻟﺤـﺎﻟﻲ ﺑﺎﺳـﺘﺨﺪام اﻻﻣـﺮﻳﻦ ‪ ChDrive‬و ‪ ،ChDir‬اﻻول‬
                                          ‫ﻟﺘﻐﻴﻴﺮ اﻟﻘﺮص واﻟﺜﺎﻧﻲ ﻟﺘﻐﻴﻴﺮ اﻟﺪﻟﻴﻞ:‬

‫”:‪ChDrive “D‬‬
‫”‪ChDir “D:\MsgFolder‬‬

 ‫ان ﻗﻤــﺖ ﺑﺘﻐﻴﻴــﺮ اﻟــﺪﻟﻴﻞ اﻟﺤــﺎﻟﻲ ﺑﺎﺳــﺘﺨﺪام اﻻﻣــﺮ ‪ ChDir‬ﻓﻘــﻂ دون‬   ‫ﻣﻼﺣﻈﺔ:‬
 ‫ﺗﻐﻴﻴــﺮ اﻟﻘــﺮص ﺑﺎﺳــﺘﺨﺪام اﻻﻣــﺮ ‪ ،ChDrive‬ﻓﺴــﺘﻘﻮم ﺑﺘﻐﻴﻴــﺮ اﻟــﺪﻟﻴﻞ‬
 ‫اﻟﺤﺎﻟﻲ ﻟﺬﻟﻚ اﻟﻘﺮص ﻓﻘﻂ، اﻣﺎ اﻟﺪﻟﻴﻞ اﻟﺤﺎﻟﻲ اﻟﺬي ﺳﺘﻌﻮد ﺑـﻪ اﻟﺪاﻟـﺔ‬
                                                   ‫$‪ CurDir‬ﻟﻢ ﻳﺘﻐﻴﺮ.‬

‫اذا آﻨﺖ ﻻ ﺗﻌﺮف ﻣﺎ اﻟﻔﺎﺋﺪة ﻣﻦ ﻣﻌﺮﻓﺔ اﻟﺪﻟﻴﻞ اﻟﺤﺎﻟﻲ ﻟﻠﻘﺮص، ﻓﻴﺒﺪو ان ﻋﺼﺮ اﻟﺒﺮﻣﺠﺔ‬
‫ﺗﺤﺖ اﻟﻨﻈﺎم ‪ MS-DOS‬ﻟﻢ ﺗﺸﻬﺪﻩ اﺻﺎﺑﻌﻚ اﻟﺮﻗﻴﻘﺔ. ﺑﺸﻜﻞ ﻣﺒﺴﻂ، اﻟﻔﺎﺋﺪة اﻟﺘـﻲ ﻗـﺪ‬
‫ﺗﺠﻨﻴﻬﺎ ﻣﻦ ﺗﻐﻴﻴﺮ اﻟﺪﻟﻴﻞ اﻟﺤﺎﻟﻲ هﻮ ﻋﺪم اﻟﺤﺎﺟﺔ اﻟﻰ ﺗﺤﺪﻳﺪ ﻣﺴﺎر اﻟﻤﻠﻔﺎت ﻓﻲ ذﻟـﻚ‬
                                                           ‫اﻟﺪﻟﻴﻞ، ﻓﻬﺬا اﻟﻜﻮد:‬

‫”:‪ChDrive “C‬‬
‫”‪ChDir “C:\UnwantedFolder‬‬
‫”*.*“ ‪Kill‬‬
                                                ‫331‬


‫ﺳـــﻴﺤﺬف ﺟﻤﻴـــﻊ اﻟﻤﻠﻔـــﺎت اﻟﻤﻮﺟـــﻮدة ﻓـــﻲ اﻟـــﺪﻟﻴﻞ اﻟﺤـــﺎﻟﻲ ﻟﻠﻘـــﺮص –وهـــﻮ‬
‫‪ ،C:\UnwantedFolder‬واﺗﻤﻨﻰ ﻣﻦ ﺻـﻤﻴﻢ ﻗﻠﺒـﻲ اﻟﺤﻨـﻮن ان ﻻ ﺗﺠﻌـﻞ دﻟﻴـﻞ اﻟﻨﻈـﺎم‬
                                ‫‪ Windows‬هﻮ اﻟﺪﻟﻴﻞ اﻟﺤﺎﻟﻲ وﺗﻄﺒﻖ اﻟﻜﻮد اﻟﺴﺎﺑﻖ.‬

                                          ‫اﻟﺒﺤﺚ ﻋﻦ اﻟﻤﻠﻔﺎت واﻟﻤﺠﻠﺪات‬
   ‫ـ‬         ‫ـ‬     ‫ـ‬          ‫ـ‬
‫ﺗﻤﻜﻨ ـﻚ اﻟﺪاﻟ ـﺔ ‪ Dir‬ﻣ ـﻦ اﻟﺒﺤ ـﺚ ﻋ ـﻦ اﻟﻤﻠﻔ ـﺎت واﻟﻤﺠﻠ ـﺪات. ﻃﺮﻳﻘ ـﺔ اﺳ ـﺘﺨﺪاﻣﻬﺎ ﻳ ـﺘﻢ‬
                                         ‫ـ‬        ‫ـ‬    ‫ـ‬       ‫ـ‬        ‫ـ‬        ‫ـ‬
‫ﺑﺨﻄﻮﺗﻴﻦ: اﻻوﻟﻰ ﺗﺤﺪﻳﺪ اﻟﻤﻠﻒ/اﻟﻤﻠﻔﺎت/اﻟﻤﺠﻠﺪ وﺧﺼﺎﺋﺼﻬﺎ، واﻟﺜﺎﻧﻴﺔ ﺑﺎﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ‬
‫دون ارﺳﺎل أي ﻗﻴﻤﺔ ﻟﻬﺎ، اﻟﻜﻮد اﻟﺘﺎﻟﻲ ﻳﺒﺤﺚ ﻋﻦ ﺟﻤﻴﻊ اﻟﻤﻠﻔﺎت اﻟﺘﻨﻔﻴﺬﻳﺔ اﻟﻤﻮﺟـﻮدة‬
                                                            ‫ﻓﻲ اﻟﻤﺠﻠﺪ ‪: C:\WinNT‬‬

‫‪Dim sFileName As String‬‬

‫اﻟﺨﻄﻮة اﻻوﻟﻰ ‘‬
‫)”‪sFileName = Dir$ (“C:\Winnt\*.EXE‬‬
‫اﻟﺨﻄﻮة اﻟﺜﺎﻧﻴﺔ ‘‬
‫)‪Do While Len (sFileName‬‬
          ‫‪List1.AddItem sFileName‬‬
          ‫$‪sFileName = Dir‬‬
‫‪Loop‬‬


                                                                  ‫ﺗﺤﺮﻳﺮ اﻟﻤﻠﻔﺎت‬
‫ﺑﺎﻻﺿﺎﻓﺔ اواﻣﺮ ودوال اﻻﺳﺘﻌﻼم ﻋﻦ اﻟﻤﻠﻔﺎت واﻟﻤﺠﻠﺪات اﻟﺴﺎﺑﻘﺔ، ﺗـﻮﻓﺮ ﻟـﻚ ﻣﻜﺘﺒـﺎت‬
‫‪ VB‬و ‪ VBA‬اواﻣﺮ ودوال اﺧﺮى ﺗﻤﻜﻨﻚ ﻣﻦ ﺗﺤﺮﻳﺮ اﻟﻤﻠﻔـﺎت ﻟﺤﻔـﻆ ﺑﻴﺎﻧـﺎت ﺑﺮاﻣﺠـﻚ ﻓﻴﻬـﺎ‬
‫ﺑﺎﻟﺘﻨﺴﻴﻖ واﻟﻬﻴﺌﺔ اﻟﺘﻲ ﺗﺮﻳﺪهﺎ. ﻗﺒﻞ اﺟﺮاء أي ﻋﻤﻠﻴﺎت ﺗﺤﺮﻳﺮ ﻋﻠﻰ اﻟﻤﻠـﻒ، ﻻﺑـﺪ ﻣـﻦ‬
                                       ‫ﻓﺘﺤﻪ ﺑﺎﺳﺘﺨﺪام اﻟﻌﺒﺎرة ‪ Open‬اﻟﺘﻲ ﺿﻴﻐﺘﻬﺎ:‬

‫رﻗﻢ اﻟﻤﻠﻒ# ‪ As‬اﻻﻗﻔﺎل ‪ Lock‬ﻧﻮع اﻟﻮﺻﻮل ‪ For‬اﺳﻢ اﻟﻤﻠﻒ ‪Open‬‬

‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﺮﻗﻢ اﻟﻤﻠﻒ، ﻓﻬﻮ رﻗﻢ ﻳﻤﺜﻞ اﻟﻤﻠﻒ ﺑﺤﻴﺚ ﻳﻤﻜﻨﻚ اﻟﻮﺻﻮل اﻟﻴﻪ ﻣﻦ آﺎﻓﺔ اﻧﺤﺎء‬
‫اﻟﺒﺮﻧﺎﻣﺞ، وﻻ ﻳﻤﻜﻦ ﻟﻬﺬا اﻟﺮﻗﻢ ان ﻳﺸﻤﻞ اآﺜﺮ ﻣـﻦ ﻣﻠـﻒ واﺣـﺪ، ﻟـﺬﻟﻚ ﺣﺘـﻰ ﺗﺘﻔـﺎدى‬
‫اﺧﻄﺎء اﻟﺘﻌﺎرض، ﻳﻔﻀﻞ اﺳﺘﺨﺪام اﻟﺪاﻟﺔ ‪ FreeFile‬اﻟﺘﻲ ﺗﻌﻮد ﺑـﺮﻗﻢ ﻏﻴـﺮ ﻣﺤﺠـﻮز ﻟﻔـﺘﺢ‬
‫اﻟﻤﻠﻒ. وﺑﺎﻟﻨﺴﺒﺔ ﻟﻼﻗﻔﺎل، ﻓﻬﻲ ﺗﻤﻜﻨﻚ ﻣﻦ ﺗﺤﺪﻳﺪ ﺧﺎﺻﻴﺔ اﻻﻗﻔﺎل ﻋﻠﻰ اﻟﻤﻠﻒ ﺑﺤﻴﺚ‬
‫ﻳﻤﻜﻨﻚ ﻣﻨﻊ آﺎﻓﺔ اﻟﺒﺮاﻣﺞ اﻻﺧـﺮى ﻣـﻦ اﻟﻘـﺮاءة ﻣـﻦ اﻟﻤﻠـﻒ ‪ ،Lock Read‬اﻟﻜﺘﺎﺑـﺔ اﻟـﻰ‬
                                              ‫431‬


‫اﻟﻤﻠﻒ ‪ Lock Write‬او اﻟﻘﺮاءة واﻟﻜﺘﺎﺑﺔ ﻣﻦ واﻟـﻰ اﻟﻤﻠـﻒ ‪ .Lock Read Write‬اﻣـﺎ ﻧـﻮع‬
           ‫اﻟﻮﺻﻮل، ﻓﻬﻲ اﻟﻄﺮﻳﻘﺔ اﻟﺘﻲ ﺗﻮد ان ﺗﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﻠﻒ ﺑﻬﺎ وهﻲ ﺛﻼﺛﺔ اﻧﻮاع:‬

                                      ‫اﻟﻮﺻﻮل اﻟﻤﺘﺘﺎﻟﻲ ‪:Sequential Access‬‬
‫اﻻﺳﻠﻮب اﻟﻤﺘﺒﻊ ﻣﻊ اﻟﻮﺻـﻮل اﻟﻤﺘﺘـﺎﻟﻲ ﻳﻌـﺮف ﺑـﺎﻟﻘﺮاءة واﻟﻜﺘﺎﺑـﺔ ﺳـﻄﺮ ﺳـﻄﺮ. وﻟﻔـﺘﺢ‬
   ‫ـ‬       ‫ـ‬               ‫ـ‬                    ‫ـ‬                   ‫ـ‬
‫اﻟﻤﻠـﻒ، اﺳـﺘﺨﺪم اﻟﻜﻠﻤـﺔ اﻟﻤﺤﺠـﻮزة ‪ Input‬ﻟﻠﻘـﺮاءة ﻣـﻦ اﻟﻤﻠـﻒ، اﻟﻜﻠﻤـﺔ اﻟﻤﺤﺠـﻮزة‬
        ‫‪ OutPut‬ﻟﻠﻜﺘﺎﺑﺔ اﻟﻰ اﻟﻤﻠﻒ واﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ Append‬ﻟﻼﺿﺎﻓﺔ اﻟﻰ اﻟﻤﻠﻒ:‬

‫1# ‪Open “MyFile.TXT” For Input As‬‬
‫2# ‪Open “MyFile2.TXT” For OutPut As‬‬
‫3# ‪Open “MyFile3.TXT” For Append As‬‬

‫ﺑﺎﻣﻜﺎﻧﻚ ﻗﺮاءة ﺳﻄﻮر ﻣﻦ اﻟﻤﻠﻔﺎت -اﻟﻤﻔﺘﻮﺣـﺔ ﺑﺎﻟﻜﻠﻤـﺔ اﻟﻤﺤﺠـﻮزة ‪ -Input‬ﺑﺎﺳـﺘﺨﺪام‬
       ‫اﻟﻌﺒﺎرة ‪ Line Input‬ﺣﺘﻰ ﻧﻬﺎﻳﺔ اﻟﻤﻠﻒ واﻟﺬي ﺗﺨﺘﺒﺮﻩ ﻋﻦ ﻃﺮﻳﻖ اﻟﺪاﻟﺔ ‪:EOF‬‬

‫‪Dim sLine As String‬‬

‫1# ‪Open “MyFile.TXT” For Input As‬‬
‫)1(‪Do While Not EOF‬‬
      ‫‪Line Input #1, sLine‬‬
      ‫‪Text1.Text = Text1.Text & vbNewLine & sLine‬‬
‫‪Loop‬‬

‫اﻟﻜﻮد اﻟﺴﺎﺑﻖ ﻻ اﺳﺘﺨﺪﻣﻪ آﺜﻴﺮا ﻓﺄﻧﺎ اﻓﻀﻞ ﻗﺮاءة اﻟﻤﻠﻒ آﺎﻣﻼ ﺑﺪاﻟـﺔ واﺣـﺪة ﺗﺴـﻤﻰ‬
       ‫$‪ ،Input‬واﺳﺘﺨﺪم ﻓﻲ ذﻟﻚ اﻟﺪاﻟﺔ ‪ LOF‬اﻟﺘﻲ ﺗﻌﻮد ﺑﺎﻟﺤﺠﻢ اﻟﻜﻠﻲ ﻟﻠﻤﻠﻒ:‬

‫‪Dim sFileData As String‬‬

‫1# ‪Open "C:\MyFile.TXT" For Input As‬‬
‫)1 ,)1(‪sFileData = Input$ (LOF‬‬
‫‪Text1.Text = sFileData‬‬

‫وﺑﺎﻣﻜﺎﻧــﻚ آﺘﺎﺑــﺔ ﺳــﻄﻮر اﻟــﻰ اﻟﻤﻠﻔــﺎت -اﻟﻤﻔﺘﻮﺣــﺔ ﺑﺎﻟﻜﻠﻤــﺔ اﻟﻤﺤﺠــﻮزة ‪ OutPut‬و‬
                                              ‫‪ -Append‬ﺑﺎﺳﺘﺨﺪام اﻟﻌﺒﺎرة # ‪:Print‬‬

‫1# ‪Open “C:\MyFile.TXT” For Append As‬‬
                                              ‫531‬


‫‪Print #1, Text1.Text‬‬

           ‫ـ‬         ‫ـ‬    ‫ـ‬                          ‫ـ‬      ‫ـ‬        ‫ـ‬     ‫ـ‬
‫وﻻ ﺗﻨﺴ ـﻰ اﻏ ـﻼق اﻟﻤﻠ ـﻒ ﺑﺎﺳ ـﺘﺨﺪام اﻟﻌﺒــﺎرة ‪ Close‬اﻟﺘ ـﻲ ﺳ ـﺘﻐﻠﻖ آﺎﻓ ـﺔ اﻟﻤﻠﻔــﺎت‬
                                          ‫اﻟﻤﻔﺘﻮﺣﺔ ان ﻟﻢ ﺗﺮﺳﻞ ﻟﻬﺎ رﻗﻢ ﻣﻠﻒ ﻣﻌﻴﻦ:‬

‫اﻏﻼق اﻟﻤﻠﻒ رﻗﻢ 1 ‘‬
‫1# ‪Close‬‬
‫اﻏﻼق آﺂﻓﺔ اﻟﻤﻠﻔﺎت ‘‬
‫‪Close‬‬

                                             ‫اﻟﻮﺻﻮل اﻟﺜﻨﺎﺋﻲ ‪:Binary Access‬‬
‫اﻻﺳﻠﻮب اﻟﻤﺘﺒﻊ ﻣﻊ اﻟﻮﺻﻮل اﻟﺜﻨﺎﺋﻲ ﻳﻌﺮف ﺑﺎﻟﻘﺮاءة واﻟﻜﺘﺎﺑﺔ ﺑﺎﻳﺖ ﺑﺎﻳﺖ. وﻟﻔﺘﺢ اﻟﻤﻠﻒ،‬
               ‫اﺳﺘﺨﺪم اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ Binary‬ﻟﻠﻘﺮاءة واﻟﻜﺘﺎﺑﺔ ﻣﻦ واﻟﻰ اﻟﻤﻠﻒ:‬

‫1# ‪Open "C:\MyFile.DAT" For Binary As‬‬
‫2# ‪Open "D:\YouFile.DAT" For Binary As‬‬

‫ﻋﻤﻠﻴﺔ اﻟﻘﺮاءة واﻟﻜﺘﺎﺑﺔ ﻣﻦ اﻟﻤﻠﻒ ﻣﺘﺸﺎﺑﻬﺘﺎن ﻣﻦ ﻧﺎﺣﻴﺔ اﻟﺼﻴﻐﺔ اﻟﻰ ﺣﺪ آﺒﻴﺮ. آﻞ ﻣﺎ‬
‫هﻮ ﻣﻄﻠﻮب ﻣﻨﻚ هﻮ ﻣﻌﺮﻓﺔ اﻟﻤﻮﻗـﻊ ﻓـﻲ اﻟﻤﻠـﻒ وﺣﺠـﻢ اﻟﻌﻤﻠﻴـﺔ. ﻋﻨـﺪﻣﺎ ﺗﻘـﻮم ﺑﻔـﺘﺢ‬
‫اﻟﻤﻠﻒ ﻻول ﻣﺮة، ﻓﺎن ﻣﻮﻗﻊ ﻣﺆﺷﺮ اﻟﻘﺮاءة واﻟﻜﺘﺎﺑﺔ ﻣـﻦ اﻟﻤﻠـﻒ هـﻮ 1، وهـﻮ اول ﺑﺎﻳـﺖ‬
‫ﻣﻮﺟﻮد ﻓﻲ ﺧﺎرﻃﺔ اﻟﻤﻠﻒ. ﻟﻤﻌﺮﻓﺔ ﻣﻮﻗﻊ اﺧﺮ ﺑﺎﻳﺖ اﺳﺘﺨﺪم اﻟﺪاﻟـﺔ ‪ LOF‬واﻟﺘـﻲ ﺗﻌـﻮد‬
                            ‫ﺑﺤﺠﻢ اﻟﻤﻠﻒ واﻟﺬي ﺑﺪﻳﻬﻴﺎ ﻳﺮﻣﺰ اﻟﻰ ﻣﻮﻗﻊ اﻟﺒﺎﻳﺖ اﻻﺧﻴﺮ:‬

‫)1( ‪Print LOF‬‬
‫)2( ‪Print LOF‬‬

‫اﻟﺬي آﻨﺖ اﻗﺼﺪﻩ ﻣﻦ "ﺣﺠﻢ اﻟﻌﻤﻠﻴﺔ" هﻮ ﺣﺠﻢ اﻟﺒﺎﻳﺘﺎت اﻟﺘﻲ ﺗﺮﻳﺪ ﻗﺮاءﺗﻬﺎ ﻣﻦ اﻟﻤﻠﻒ‬
‫او آﺘﺎﺑﺘﻬﺎ اﻟﻰ اﻟﻤﻠﻒ. آﻞ هﺬا ﻳﺘﻢ ﺑﺎﺳﺘﺨﺪام اﻻﻣﺮ ‪ Get‬ﻟﻠﻘﺮاءة او ‪ Put‬ﻟﻠﻜﺘﺎﺑﺔ. راﻗـﺐ‬
                                                                    ‫هﺬا اﻟﻜﻮد:‬

‫‪Dim X As Long‬‬

‫‪Get #1, 1, X‬‬
‫‪Print X‬‬
                                            ‫631‬


‫ﻣﻮﻗﻊ اﻟﻤﺆﺷﺮ هﻮ 5 ‘ ‪Get #1, , X‬‬
‫‪Print X‬‬

‫ﻣﻦ اﻟﻤﻬﻢ اﻟﺘﻨﻮﻳﻪ هﻨﺎ ﺑﺎن ﻋﻤﻠﻴﺔ اﻟﻘﺮاءة ﻣﻦ اﻟﻤﻠﻒ ﺗﺆدي اﻟﻰ زﻳـﺎدة اﻟﻤﻮﻗـﻊ اﻟﺤـﺎﻟﻲ‬
‫ﻟﻠﻤﺆﺷﺮ ﺑﻤﻘﺪار ﺣﺠﻢ اﻟﻌﻤﻠﻴﺔ. ﻓﻔﻲ اﻟﺴـﻄﺮ اﻟﺜـﺎﻧﻲ ﻟـﻢ اﺣـﺪد ﻣﻮﻗـﻊ اﻟﻤﺆﺷـﺮ، ﻻﻧـﻪ‬
‫ﺳﻴﺰﻳﺪ ﺑﺸﻜﻞ ﺗﻠﻘﺎﺋﻲ 4 ﺑﺎﻳﺘﺎت وذﻟـﻚ ﺑﺴـﺒﺐ ان ﺣﺠـﻢ اﻟﻌﻤﻠﻴـﺔ اﻟﺴـﺎﺑﻖ = 4 ﺑﺎﻳـﺖ‬
‫ﻟﻘﺮاءة ﻗﻴﻤﺔ ﻣﻦ ﻧﻮع ‪ .Long‬هﺬا اﻟﻜﻮد ﻳﻘﻮم ﺑﻘﺮاءة ﺟﻤﻴـﻊ اﻻرﻗـﺎم ﻣـﻦ ﻣﻠـﻒ وآﺘﺎﺑﺘﻬـﺎ‬
                                                                  ‫ﻓﻲ ﻣﻠﻒ اﺧﺮ:‬

‫‪Dim lCounter As Long‬‬
‫‪Dim X As Long‬‬

‫)1(‪For lCounter = 1 To LOF‬‬
  ‫‪Get #1, , X‬‬
  ‫‪Put #2, , X‬‬
‫‪Next‬‬

                            ‫ﻳﻤﻜﻨﻚ ﺗﻐﻴﻴﺮ ﻣﻮﻗﻊ ﻣﺆﺷﺮ اﻟﻤﻠﻒ ﻋﻦ ﻃﺮﻳﻖ اﻟﻌﺒﺎرة ‪:Seek‬‬

‫1 ,1# ‪Seek‬‬              ‫اﻟﻰ ﺑﺪاﻳﺔ اﻟﻤﻠﻒ ‘‬
‫)2(‪Seek #2, LOF‬‬         ‫اﻟﻰ ﻧﻬﺎﻳﺔ اﻟﻤﻠﻒ ‘‬

‫ﺑﺪون ﺷﻚ ﺗﺤﺘﺎج اﻟﻰ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻘﻴﻢ اﻟﺤﺮﻓﻴﺔ ‪ Strings‬واﻟﺘﻲ ﺗـﺘﻢ ﺑـﻨﻔﺲ اﻟﻄﺮﻳﻘـﺔ‬
‫ﻟﻜﻨﻚ ﺑﺤﺎﺟﺔ اﻟﻰ اﻋﻄﺎء ‪ Visual Basic‬ﻣﻌﻠﻮﻣﺎت ﻋـﻦ ﺣﺠـﻢ اﻟﻘﻴﻤـﺔ اﻟﺤﺮﻓﻴـﺔ. ﻳﻤﻜﻨـﻚ‬
‫ﻋﻤﻞ ذﻟﻚ؟ ﺑﺎﺳﺘﺨﺪام اﻟﻨﻮع اﻟﺤﺮﻓﻲ اﻟﺜﺎﺑﺖ اﻟﺤﺠﻢ ‪ .Fixed Length String‬آﻤـﺎ ﻓـﻲ‬
                                ‫اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ واﻟﺬي ﺳﻴﻘﺮأ 001 ﺑﺎﻳﺖ ﻣﻦ اﻟﻤﻠﻒ:‬

‫001 * ‪Dim Y As String‬‬

‫‪Get #1, , Y‬‬

‫واذا آﻨﺖ ﻻ ﺗﻔﻀﻞ اﺳﺘﺨﺪام هﺬا اﻟﻨﻮع ﻣﻦ اﻟﻤﺘﻐﻴﺮات، ﻓﻴﻤﻜﻨﻚ ﻋﻤﻞ أي ﺷـﺊ ﺗﺨﺒـﺮ‬
‫ﻓﻴﻪ ‪ Visual Basic‬ان ﺣﺠﻢ اﻟﻤﺘﻐﻴﺮ اﻟﺤﺮﻓﻲ هﻮ 001 وذﻟﻚ ﻋﻦ ﻃﺮﻳﻖ اﺳﻨﺎد أي ﻗﻴﻤﺔ‬
                                                                 ‫ﻣﺆﻗﺘﺔ:‬

‫‪Dim Y As String‬‬
                                           ‫731‬



‫)"*" ,001( ‪Y = String‬‬

‫‪Get #1, , Y‬‬

       ‫وﻋﻤﻠﻴﺔ آﺘﺎﺑﺔ اﻟﻘﻴﻢ اﻟﺤﺮﻓﻴﺔ اﻟﻰ اﻟﻤﻠﻒ ﻳﻤﻜﻦ ﻟﻬﺎ ان ﺗﺘﻢ ﺑﺸﻜﻞ ﻣﺒﺎﺷﺮ ﻣﺜﻞ:‬

‫”ﻣﻠﻒ ﺛﻨﺎﺋﻲ“ , ,1# ‪Put‬‬

‫ﺗﺬآﺮ داﺋﻤﺎ ان اﻟﻨﻮع ‪ String‬هﻮ ﺗﺮﻣﻴﺰ اﺣﺎدي ﻓﻲ اﻟﺬاآﺮة ﻣﻤﺎ ﻳﺆدي اﻟﻰ ﺑﻄﺊ ﻋﻤﻠﻴـﺔ‬
‫اﻟﺘﺤﻮﻳﻞ ﺧﺎﺻﺔ ﻓﻲ ﺣﺎﻟﺔ آﻮن اﻟﻘـﻴﻢ اﻟﺤﺮﻓﻴـﺔ آﺒﻴـﺮ ﺟـﺪا. وﻟﺰﻳـﺎدة اﻟﺴـﺮﻋﺔ اآﺜـﺮ ﻣـﻦ‬
‫05%، اﺳﺘﺨﺪم ﻋﻤﻠﻴﺔ اﻟﻤﺼﻔﻮﻓﺎت ﻟﻠﻨﻮع ﻟﻬﺬا اﻟﻨﻮع ﻣﻦ اﻟﻘﻴﻢ -اﻟﻨـﻮع ‪ Byte‬ﺑـﺪﻻ ﻣـﻦ‬
                                                                        ‫‪:String‬‬

‫‪Dim MyArray(1000) As Byte‬‬

‫1# ‪Open "MyFile.DAT" For Binary As‬‬

‫آﺘﺎﺑﺔ ﻣﺤﺘﻮﻳﺎت اﻟﻤﺼﻔﻮﻓﺔ اﻟﻰ اﻟﻤﻠﻒ '‬
‫‪Put #1, 1, MyArray‬‬

‫او ﻗﺮاﺋﺔ ﻣﺤﺘﻮﻳﺎت اﻟﻤﻠﻒ اﻟﻰ اﻟﻤﺼﻔﻮﻓﺔ '‬
‫‪Get #1, 1, MyArray‬‬

                                        ‫اﻟﻮﺻﻮل اﻟﻌﺸﻮاﺋﻲ ‪:Random Access‬‬
‫اﻻﺳﻠﻮب اﻟﻤﺘﺒﻊ ﻣﻊ اﻟﻮﺻﻮل اﻟﻌﺸﻮاﺋﻲ ﻳﻌﺮف ﺑﺎﻟﻘﺮاءة واﻟﻜﺘﺎﺑﺔ ﺳـﺠﻞ ﺳـﺠﻞ. وﻟﻔـﺘﺢ‬
‫اﻟﻤﻠﻒ، اﺳﺘﺨﺪم اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ Random‬ﻟﻠﻘﺮاءة واﻟﻜﺘﺎﺑـﺔ ﻣـﻦ واﻟـﻰ اﻟﻤﻠـﻒ ﻣـﻊ‬
                                                        ‫ارﺳﺎل ﺣﺠﻢ اﻟﺴﺠﻞ:‬

‫002 = ‪Open "C:\MyData.DAT" For Random As #1 Len‬‬

‫اﺳﺘﺨﺪم اﻟﻌﺒﺎرة ‪ Put‬ﻟﻠﻜﺘﺎﺑﺔ اﻟﻰ اﻟﻤﻠﻒ واﻟﻌﺒﺎرة ‪ Get‬ﻟﻠﻘـﺮاءة ﻣـﻦ اﻟﻤﻠـﻒ آﻤـﺎ آﻨـﺖ‬
‫ﺗﻔﻌﻞ ﻣﻊ اﻟﻤﻠﻔـﺎت اﻟﺜﻨﺎﺋﻴـﺔ، وﻟﻜـﻦ ﻋﻠﻴـﻚ ﻣﻌﺮﻓـﺔ ان ﺣﺠـﻢ اﻟﻌﻤﻠﻴـﺔ وﺧﻄـﻮات اﻧﺘﻘـﺎل‬
              ‫اﻟﻤﺆﺷﺮ ﺗﺘﺄﺛﺮ ﺑﺎﻟﺤﺠﻢ اﻟﻤﺼﺮح ﻋﻨﺪ ﻓﺘﺢ اﻟﻤﻠﻒ ﺑﺎﺳﺘﺨﺪام اﻟﻜﻠﻤﺔ ‪.Len‬‬
                                         138


‫ﻳﻔﻴﺪك هﺬا اﻟﻨﻮع ﻣﻦ اﻟﻤﻠﻔﺎت ﻟﻤﺤﺎآﺎة ﻗﻮاﻋﺪ اﻟﺒﻴﺎﻧﺎت ﺑﻄﺮﻳﻘﺔ ﻣﺒﺴﻄﺔ، ﻣـﺜﻼ ﻳﻤﻜﻨـﻚ‬
                                       :‫ واﻟﻜﺘﺎﺑﺔ اﻟﻰ اﻟﻤﻠﻒ‬UDT ‫ﺗﻌﺮﻳﻒ ﺗﺮآﻴﺐ‬

Private Type typRCD
   sName As String * 20
   iAge As Integer
End Type

Dim Record As typRCD
Open "C:\MyData.DAT" For Random As #1 Len = Len(Record)
Record.sName = "‫"ﺗﺮآﻲ‬
Record.iAge = 99
Put #1, 1, Record
Record.sName = "‫"ﻋﺒﺪاﷲ‬
Record.iAge = 20
Put #1, , Record

                                           :‫وﻗﺮاءة اﻟﺴﺠﻼت ﺗﺘﻢ ﺑﻬﺬﻩ اﻟﻄﺮﻳﻘﺔ‬

Dim Record As typRCD
Get #1, 1, Record
Do While Not EOF(1)
Print Record.sName
Print Record.iAge
Get #1, , Record
Loop



                                                                 ‫آﺎﺋﻨﺎت اﺧﺮى‬
‫ ﻣﺠﻤﻮﻋﺔ ﻻ ﻏﻨـﻰ‬VBA ‫ و‬VB ‫اﻟﻰ ﺟﺎﻧﺐ اﻟﺪوال واﻻﺟﺮاءات اﻟﺴﺎﺑﻘﺔ، ﺗﻮﻓﺮ ﻟﻚ ﻣﻜﺘﺒﺎت‬
                          .‫ﻋﻨﻬﺎ ﻣﻦ اﻟﻜﺎﺋﻨﺎت اﻟﻤﺴﺘﺨﺪﻣﺔ ﻓﻲ ﺑﺮاﻣﺠﻚ اﻟﺠﺪﻳﺔ‬
                                               ‫931‬


                                                           ‫آﺎﺋﻦ اﻟﺒﺮﻧﺎﻣﺞ ‪App‬‬
‫آﺎﺋﻦ اﻟﺒﺮﻧﺎﻣﺞ ‪ App‬ﻳﻤﺜﻞ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺤﺎﻟﻲ اﻟﺬي ﻳﺘﻢ ﺗﻨﻔﻴـﺬﻩ. ﻳﺤﺘـﻮي ﻋﻠـﻰ ﻣﺠﻤﻮﻋـﺔ‬
‫ﻣﻦ اﻟﺨﺼﺎﺋﺺ واﻟﻄﺮق اﻟﺘﻲ ﺳﺄﺗﻄﺮق اﻟﻰ ﺑﻌﻀﻬﺎ هﻨﺎ، اﻣﺎ اﻟﺒﻘﻴﺔ ﻓﻬﻲ ﻣﺘﻘﺪﻣﺔ ﺑﻌﺾ‬
                                     ‫اﻟﺸﺊ واﻓﻀﻞ ﺗﺄﺟﻴﻠﻬﺎ اﻟﻰ اﻟﻔﺼﻮل اﻟﻼﺣﻘﺔ.‬
‫اﻟﺨﺎﺻﻴﺔ ‪ EXEName‬ﺗﻌﻮد ﺑﺎﺳﻢ ﻣﻠﻒ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﻨﻔﻴـﺬي ‪ ،EXE‬واﻟﺨﺎﺻـﻴﺔ ‪ Path‬ﺗﻌـﻮد‬
                                          ‫ﺑﺎﻟﻤﺴﺎر اﻟﻜﺎﻣﻞ اﻟﺬي ﻧﻔﺬ اﻟﺒﺮﻧﺎﻣﺞ ﻣﻨﻪ:‬

‫1# ‪Open App.Path & “\” & App.EXEName & “.EXE” For Binary As‬‬

‫ﻣــﻦ اﻟﻀــﺮوري اﻟﺘﺤﻘــﻖ ﻣــﻦ اﻟﺮﻣــﺰ "\" ﻗﺒــﻞ اﺳــﺘﺨﺪام اﻟﺨﺎﺻــﻴﺔ ‪ ،Path‬ﻓﻔــﻲ اﻟﻜــﻮد‬
‫اﻟﺴﺎﺑﻖ اﺿﻔﻨﺎ هﺬا اﻟﺮﻣﺰ ﺑﻌﺪ اﻟﺨﺎﺻﻴﺔ ‪ Path‬وذﻟﻚ ﻻن ﻣﺴﺎر اﻟﺒﺮﻧﺎﻣﺞ ﻟﻦ ﻳﻀـﺎف اﻟﻴـﻪ‬
‫هﺬا اﻟﺮﻣﺰ، وﻟﻜﻦ ﺗﻈﻬﺮ اﻟﻤﺸﻜﻠﺔ ﻓﻲ اﻟﻜﻮد اﻟﺴﺎﺑﻖ اذا ﺗﻤـﺖ ﻋﻤﻠﻴـﺔ ﺗﻨﻔﻴـﺬ اﻟﺒﺮﻧـﺎﻣﺞ‬
‫ﻣﻦ اﻟﺪﻟﻴﻞ اﻟﺠﺬري ‪ Boot Directory‬ﻟﻠﻘﺮص، اﻧﻈﺮ اﻟﻰ اﻟﺮﻣﺰ "\" ﻓـﻲ ﻗﻴﻤـﺔ اﻟﺨﺎﺻـﻴﺔ‬
                                     ‫‪ Path‬اذا ﻧﻔﺬ اﻟﺒﺮﻧﺎﻣﺞ ﻣﻦ دﻟﻴﻞ ﺟﺬري او ﻓﺮﻋﻲ:‬

‫”\:‪App.Path = “C‬‬          ‫اﻟﺮﻣﺰ ﻣﻀﺎف ‘‬
‫اﻟﺮﻣﺰ ﻏﻴﺮ ﻣﻀﺎف ‘ ”‪App.Path = “C:\MyProgram‬‬

‫وﺣﺘﻰ ﺗﺘﺠﻨﺐ اﻟﻤﺸﻜﻠﺔ اﻟﺴﺎﺑﻘﺔ، ﻃﻮر هﺬﻩ اﻟﺪاﻟﺔ وﺣﺎول اﻻﻋﺘﻤـﺎد ﻋﻠﻴـﻪ ﻋﻮﺿـﺎ ﻋـﻦ‬
                                                        ‫اﻟﺨﺎﺻﻴﺔ ‪ Path‬ﻣﺠﺮدة:‬

‫‪Function PathEx() As String‬‬
  ‫‪If Right(App.Path, 1) = "\" Then‬‬
     ‫‪PathEx = App.Path‬‬
  ‫‪Else‬‬
     ‫"\" & ‪PathEx = App.Path‬‬
  ‫‪End If‬‬
‫‪End Function‬‬

‫1# ‪Open PathEx & App.EXEName & “.EXE” For Binary As‬‬

‫اﻟﺨﺎﺻﻴﺔ ‪ PrevInstance‬ﺗﻤﻜﻨﻚ ﻣﻦ ﻣﻌﺮﻓﺔ ﻣـﺎ اذا آﺎﻧـﺖ ﻧﺴـﺨﺔ اﺧـﺮى ﻣـﻦ اﻟﺒﺮﻧـﺎﻣﺞ‬
‫اﻟﺘﻨﻔﻴﺬي ﻗﻴﺪ اﻟﻌﻤﻞ او ﻻ، ﻗﺪ ﺗﺴﺘﻄﻴﻊ ﻣﻨﻊ اﻟﻤﺴﺘﺨﺪم ﻣﻦ ﺗﺸﻐﻴﻞ اآﺜﺮ ﻣـﻦ ﻧﺴـﺨﺔ‬
                                            ‫ﻟﻠﺒﺮﻧﺎﻣﺞ ﻓﻲ ﻧﻔﺲ اﻟﻮﻗﺖ ﺑﻬﺬا اﻟﻜﻮد:‬
                                              ‫041‬


‫‪If App.PrevInstance Then‬‬
       ‫”ﻻ ﻳﻤﻜﻨﻚ ﺗﺸﻐﻴﻞ ﻧﺴﺨﺔ اﺧﺮى ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ“ ‪MsgBox‬‬
       ‫‪End‬‬
‫‪End If‬‬

‫ﻣﻊ ذﻟﻚ، ﻻ ﺗﺜﻖ ﻓﻲ اﻟﻜـﻮد اﻟﺴـﺎﺑﻖ آﺜﻴـﺮا، ﻓﺎﻟﻤﺴـﺘﺨﺪم ﺑﺎﻣﻜﺎﻧـﻪ ﺗﺸـﻐﻴﻞ اآﺜـﺮ ﻣـﻦ‬
‫ﻧﺴﺨﺔ ﻣﻦ ﻧﻔﺲ اﻟﺒﺮﻧﺎﻣﺞ اذا ﻗﺎم ﺑﻨﺴﺦ ﻣﻠﻒ اﻟﺒﺮﻧﺎﻣﺞ اﻟﻰ ﻣﺠﻠﺪ اﺧـﺮ او ﺣﺘـﻰ اﻟـﻰ‬
                                                             ‫ﻧﻔﺲ اﻟﻤﺠﻠﺪ ﺑﺎﺳﻢ ﺁﺧﺮ.‬
‫ﻣﻦ اﻟﺨﺼﺎﺋﺺ اﻟﺘـﻲ ﻳﻤﻜﻨـﻚ ﺗﻌـﺪﻳﻞ ﻗﻴﻤﻬـﺎ اﻟﺨﺎﺻـﻴﺔ ‪ TaskVisible‬اﻟﺘـﻲ ﺗﻤﻜﻨـﻚ ﻣـﻦ‬
‫اﺧﻔﺎء او اﻇﻬﺎر اﺳﻢ او رﻣﺰ اﻟﺒﺮﻧﺎﻣﺞ ﻓﻲ ﻗﺎﺋﻤﺔ اﻟﺒﺮاﻣﺞ ‪ -Task List‬وهﻲ اﻟﻨﺎﻓﺬة اﻟﺘﻲ‬
‫ﺗﻤﻜﻨــﻚ ﻣــﻦ ﻋــﺮض ﺟﻤﻴــﻊ اﻟﺒــﺮاﻣﺞ اﻟﻌﺎﻣﻠــﺔ ﻋــﻦ ﻃﺮﻳــﻖ اﻟﻀــﻐﻂ ﻋﻠــﻰ اﻟﻤﻔــﺎﺗﻴﺢ‬
        ‫]‪ [Ctrl+Alt+Del‬او ]‪ ،[Ctrl+Shift+ESC‬ﻓﻼﺧﻔﺎء اﺳﻢ اﻟﺒﺮﻧﺎﻣﺞ ﻓﻲ أي وﻗﺖ:‬

‫‪App.TaskVisible = False‬‬

‫وآﺬﻟﻚ اﻟﺨﺎﺻﻴﺔ ‪ Title‬اﻟﺘﻲ ﺗﻤﻜﻨﻚ ﻣﻦ ﺗﺤﺪﻳﺪ اﻟﻨﺺ اﻟﻈﺎهﺮ ﻓﻲ ﻗﺎﺋﻤﺔ اﻟﺒـﺮاﻣﺞ ‪Task‬‬
‫‪ ،List‬ﻳﻜﻮن اﻟﻨﺺ اﻻﻓﺘﺮاﺿﻲ هﻮ اﻟﻨﺺ اﻟﻤﻮﺟﻮد ﻋﻨـﺪ ﺧﺎﻧـﺔ اﺳـﻢ اﻟﻤﺸـﺮوع ‪Project‬‬
‫‪ Name‬ﻓــﻲ ﺻــﻨﺪوق ﺣــﻮار ﺧﺼــﺎﺋﺺ اﻟﻤﺸــﺮوع ‪ Project Properties‬ﻗﺒــﻞ ﻋﻤﻠﻴــﺔ‬
                                                                            ‫اﻟﺘﺮﺟﻤﺔ.‬
‫ﻣﻦ اﻟﺨﺼﺎﺋﺺ اﻻﺧﺮى اﻟﺘﻲ ﺗﺠﺪهﺎ ﻓـﻲ ﺻـﻨﺪوق اﻟﺤـﻮار اﻟﺴـﺎﺑﻖ واﻟﻜـﺎﺋﻦ ‪ App‬هـﻲ‬
‫ﺧﺼــﺎﺋﺺ رﻗــﻢ اﺻــﺪار اﻟﺒﺮﻧــﺎﻣﺞ ‪ .... Minor ،Major‬اﻟــﺦ، وﺧﺼــﺎﺋﺺ ﺣﻘــﻮق اﻟﻤﻠﻜﻴــﺔ‬
            ‫‪ .... Trademarks ،LegalCopyRight‬اﻟﺦ وهﻲ ﻟﻠﻘﺮاءة ﻓﻘﻂ وﻗﺖ اﻟﺘﻨﻔﻴﺬ.‬

                                                ‫آﺎﺋﻦ اﻟﺤﺎﻓﻈﺔ ‪Clipboard‬‬
‫ﺗﺘﻤﻴﺰ ﻣﻌﻈﻢ ﺗﻄﺒﻴﻘﺎت ‪ Windows‬ﺑﺎﻣﻜﺎﻧﻴﺔ اﻻﺗﺼﺎل وﺗﺒﺎدل اﻟﺒﻴﺎﻧﺎت ﻓﻴﻤﺎ ﺑﻴﻨﻬـﺎ، ﺻـﺤﻴﺢ‬
‫ان ﺗﺒﺎدل اﻟﺒﻴﺎﻧﺎت ﻋﻦ ﻃﺮﻳﻖ اﻟﺤﺎﻓﻈﺔ ‪ Clipboard‬ﻣﺤـﺪود اﻻﻣﻜﺎﻧﻴـﺎت، اﻻ اﻧـﻪ اﺳـﻠﻮب‬
‫ﻣﺎزال ﻣﺘﺒﻊ ﻓﻲ ﻣﻌﻈﻢ ﺗﻄﺒﻴﻘـﺎت ‪ .Windows‬ﻳﻤﻜﻨـﻚ ‪ Visual Basic‬ﻣـﻦ ﻧﺴـﺦ وﻟﺼـﻖ‬
                            ‫اﻟﺒﻴﺎﻧﺎت ﻣﻦ واﻟﻰ اﻟﺤﺎﻓﻈﺔ ﻋﻦ ﻃﺮﻳﻖ اﻟﻜﺎﺋﻦ ‪.Clipboard‬‬
                                                                      ‫ﻻ‬
                   ‫ﻧﺒﺪأ أو ً ﺑﻨﺴﺦ اﻟﻨﺺ اﻟﻰ اﻟﺤﺎﻓﻈﺔ ﺑﺎﺳﺘﺨﺪام اﻟﻄﺮﻳﻘﺔ ‪:SetText‬‬

‫‪Clipboard.Clear‬‬
‫‪Clipboard.SetText Text1.Text, vbCFText‬‬
                                            ‫141‬


 ‫ﻳﻨﺼﺢ داﺋﻤﺎ ﺑﺎﺳﺘﺨﺪام اﻟﻄﺮﻳﻘﺔ ‪ Clear‬ﻟﻤﺴﺢ ﻣﺤﺘﻮﻳﺎت اﻟﺤﺎﻓﻈﺔ ﻗﺒـﻞ‬      ‫ﻣﻼﺣﻈﺔ:‬
 ‫ﻧﺴﺦ اﻟﺒﻴﺎﻧﺎت ﻟﻬﺎ، وذﻟﻚ ﻻﻧﻪ ﻓﻲ ﺣﺎﻻت ﻣﻌﻴﻨﺔ ﻟﻦ ﺗﺘﻤﻜﻦ ﻣـﻦ ﻧﺴـﺦ‬
              ‫ﺑﻴﺎﻧﺎت ﺟﺪﻳﺪة اﻟﻰ اﻟﺤﺎﻓﻈﺔ ﻣﺎﻟﻢ ﻳﺘﻢ ﻣﺴﺢ ﻣﺤﺘﻮﻳﺎﺗﻬﺎ.‬

        ‫وﻟﻨﺴﺦ اﻟﻨﺼﻮص ﻣﻊ ﺗﻨﺴﻴﻘﻬﺎ ﻋﻠﻰ هﻴﺌﺔ ‪ RTF‬ﻓﺎﺳﺘﺨﺪم اﻟﺜﺎﺑﺖ ‪:vbCFRTF‬‬

‫‪Clipboard.Clear‬‬
‫‪Clipboard.SetText RichTextBox1.Text, vbCFRTF‬‬

                            ‫اﻣﺎ ﻟﻨﺴﺦ اﻟﺼﻮر، ﻓﺎﻟﻄﺮﻳﻘﺔ ‪ SetData‬هﻲ اﻟﻤﺴﺘﺨﺪﻣﺔ:‬

‫‪Clipboard.Clear‬‬
‫‪Clipboard.SetData Picture1.Picture‬‬

‫وﻻﺟﺮاء ﻋﻤﻠﻴﺔ ﻟﺼﻖ اﻟﻨﺼـﻮص، ﻓﺎﻟﻄﺮﻳﻘـﺔ ‪ GetText‬هـﻲ اﻟﻤﺴـﺘﺨﺪﻣﺔ، وﻟﻜـﻦ ﻋﻠﻴـﻚ‬
‫اﺧﺘﺒﺎر ﻧﻮع وهﻴﺌﺔ اﻟﺒﻴﺎﻧﺎت اﻟﻤﻮﺟـﻮدة ﻓـﻲ اﻟﺤﺎﻓﻈـﺔ ﺑﺎﺳـﺘﺨﺪام اﻟﻄﺮﻳﻘـﺔ ‪GetFormat‬‬
                                                   ‫ﻗﺒﻞ اﻟﻘﻴﺎم ﺑﻌﻤﻠﻴﺔ اﻟﻠﺼﻖ:‬

‫‪If Clipboard.GetFormat (vbCFText) Then‬‬
        ‫)‪Text1.SelText = Clipboard.GetText (vbCFText‬‬
‫‪ElseIf Clipboard.GetFormat (vbCFRTF) Then‬‬
        ‫)‪RichTextBox1.SelRTF = Clipboard.GetText (vbCFRTF‬‬
‫‪End If‬‬

                ‫وﻟﺼﻖ اﻟﺼﻮر اﺳﺘﺨﺪم اﻟﻄﺮﻳﻘﺔ ‪ GetData‬اﻟﺘﻲ ﺗﺸﺘﺮط هﻴﺌﺔ اﻟﺼﻮرة:‬

‫‪If Clipboard.GetFormat(vbCFBitmap) Then‬‬
        ‫)‪Set Picture1.Picture = Clipboard.GetData(vbCFBitmap‬‬
‫‪End if‬‬

‫رﻏﻢ ان أداة اﻟﺼﻮرة ‪ PictureBox‬ﻳﻤﻜﻨﻬﺎ ﻋﺮض اﻧﻮاع وهﻴﺌـﺎت ﻣﺨﺘﻠﻔـﺔ ﻣـﻦ اﻟﺼـﻮر، اﻻ‬
‫ان اﻟﻜﻮد اﻟﺴﺎﺑﻖ ﻟﻦ ﻳﻌﻤﻞ اﻻ اذا آﺎﻧﺖ هﻴﺌﺔ اﻟﺼﻮرة ﻣـﻦ اﻟﻨـﻮع ‪ ،vbCFBitmap‬ﻟـﺬﻟﻚ‬
                                            ‫ﻳﻔﻀﻞ ﺗﻤﻜﻴﻦ ﺟﻤﻴﻊ اﻟﻬﻴﺌﺎت اﻻﺧﺮى:‬

‫‪Dim picFormat As Variant‬‬
                                                 ‫241‬


‫)‪For Each picFormat In Array(vbCFBitmap, vbCFMetafile, vbCFDIB, vbCFPalette‬‬
       ‫‪If Clipboard.GetFormat(picFormat) Then‬‬
               ‫)‪Set Picture1.Picture = Clipboard.GetData(picFormat‬‬
               ‫‪Exit For‬‬
       ‫‪End If‬‬
‫‪Next‬‬


                                                       ‫آﺎﺋﻦ اﻟﺸﺎﺷﺔ ‪Screen‬‬
‫آﺎﺋﻦ اﻟﺸﺎﺷﺔ ﻳﻤﺜﻞ ﺟﻤﻴﻊ ﺷﺎﺷﺎت وﻧﻮاﻓﺬ ﺑﺮﻧﺎﻣﺠﻚ وﻳﺤﺘﻮي ﻋﻠـﻰ ﺧﺼـﺎﺋﺺ ﺗﺘﻌﻠـﻖ‬
  ‫ـ‬     ‫ـ‬                 ‫ـ‬            ‫ـ‬
‫ﺑ ـﺎﻟﻤﻈﻬﺮ اﻟﻌ ـﺎم ﻟﺴ ـﻄﺢ ﻣﻜﺘ ـﺐ ﻧﻈ ـﺎم اﻟﺘﺸ ـﻐﻴﻞ، آﺎﻟﺨﺎﺻ ـﻴﺔ ‪ FontCount‬اﻟﺘ ـﻲ ﺗﻌ ـﻮد‬
                                                ‫ـ‬     ‫ـ‬       ‫ـ‬      ‫ـ‬           ‫ـ‬
‫ﺑﻤﺠﻤﻮع اﻟﺨﻄﻮط اﻟﻤﺘﻮﻓﺮة ﻓﻲ ﻧﻈﺎم اﻟﺘﺸﻐﻴﻞ واﻟﺘﻲ ﺗﺴـﺘﺨﺪﻣﻬﺎ ﻣـﻊ اﻟﺨﺎﺻـﻴﺔ ‪Font‬‬
                                                         ‫اﻟﺘﻲ ﺗﻌﻮد ﺑﺎﺳﻤﺎء اﻟﺨﻄﻮط:‬

‫‪Dim iCounter As Integer‬‬
‫1 - ‪For iCounter = 0 To Screen.FontCount‬‬
       ‫)‪List1.AddItem Screen.Fonts(iCounter‬‬
‫‪Next‬‬

‫اﻟﺨﺎﺻﻴﺔ ‪ ActiveForm‬ﺗﻤﺜﻞ ﻧﺎﻓﺬة اﻟﻨﻤﻮذج اﻟﻨﺸﻄﺔ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ، وهـﻲ ﻣﺮﺟـﻊ اﻟـﻰ‬
 ‫ـ‬       ‫ـ‬            ‫ـ‬      ‫ـ‬
‫آ ـﺎﺋﻦ ﻧﺎﻓ ـﺬة اﻟﻨﻤ ـﻮذج، اﻣ ـﺎ اﻟﺨﺎﺻ ـﻴﺔ ‪ ActiveControl‬ﻓﻬ ـﻲ ﺗﻤﺜ ـﻞ اﻻداة اﻟﺘ ـﻲ ﻋﻠﻴﻬ ـﺎ‬
                                                  ‫ـ‬        ‫ـ‬        ‫ـ‬        ‫ـ‬        ‫ـ‬
                                                                                ‫اﻟﺘﺮآﻴﺰ:‬

‫”اﻟﻨﺎﻓﺬة اﻟﻨﺸﻄﺔ“ = ‪Screen.ActiveForm.Caption‬‬

‫اﺧﻴـــﺮا، اﻟﺨﺎﺻـــﻴﺘﺎن ‪ Height‬و ‪ Width‬ﺗﻌـــﻮدان ﺑﺎرﺗﻔـــﺎع وﻋـــﺮض اﻟﻜﺜﺎﻓـــﺔ اﻟﻨﻘﻄﻴـــﺔ‬
                                                               ‫‪ Resolution‬ﻟﻠﺸﺎﺷﺔ:‬

‫)‪Print "Width = " & ScaleX(Screen.Width, vbTwips, vbPixels‬‬
‫)‪Print "Height = " & ScaleY(Screen.Height, vbTwips, vbPixels‬‬


                                                        ‫آﺎﺋﻦ اﻟﻄﺎﺑﻌﺔ ‪Printer‬‬
‫اﻟﻄﺒﺎﻋﺔ ﻣﻦ اﻟﻤﺰاﻳﺎ اﻟﻀﺮورﻳﺔ اﻟﺘﻲ ﻻﺑﺪ ﻣﻦ ﺗﻮﻓﻴﺮهﺎ ﻓـﻲ ﺑﺮاﻣﺠـﻚ اﻟﺠﺪﻳـﺔ. ﺑﻌﻴـﺪا ﻋـﻦ‬
‫اﺟﺮاءات ‪ API‬اﻟﻤﻌﻘﺪة، ﻳـﻮﻓﺮ ﻟـﻚ ‪ Visual Basic‬آـﺎﺋﻦ اﻟﻄﺎﺑﻌـﺔ ‪ Printer Object‬واﻟـﺬي‬
                                                          ‫ﻣﻦ اﺳﻤﻪ ﻳﻌﺮف ﻏﺮﺿﻪ.‬
                                               ‫341‬


‫ﻗﺒﻞ اﻟﺘﻮﻏﻞ ﻓﻲ اﻋﻀﺎء آﺎﺋﻦ اﻟﻄﺎﺑﻌﺔ اود ان اﺗﻄﺮق اﻟﻰ ﻣﺠﻤﻮﻋﺔ اﻟﻄﺎﺑﻌـﺎت ‪Printers‬‬
‫‪ .Collection‬هﺬﻩ اﻟﻤﺠﻤﻮﻋﺔ ﺗﻤﺜـﻞ ﺟﻤﻴـﻊ اﻟﻄﺎﺑﻌـﺎت اﻟﻤﻮﺟـﻮدة ﻓـﻲ اﻟﺠﻬـﺎز اﻟﺤـﺎﻟﻲ.‬
‫ﻻﺗﺴﺘﻄﻴﻊ ﺗﻌﺪﻳﻞ ﻣﺰاﻳﺎ هﺬﻩ اﻟﻄﺎﺑﻌﺎت ﺑﺸﻜﻞ ﻣﺒﺎﺷـﺮ. ﻓﻼﺑـﺪ ﻓـﻲ اﻟﺒﺪاﻳـﺔ ﻣـﻦ ﺗﺤﺪﻳـﺪ‬
                      ‫اﻟﻄﺎﺑﻌﺔ وﺗﻌﻴﻴﻨﻬﺎ ﻟﻼﺳﺘﺨﺪام وﻣﻦ ﺛﻢ ﺗﺴﺘﻄﻴﻊ ﺗﻌﺪﻳﻞ اﻟﺨﺼﺎﺋﺺ.‬
 ‫ـ‬          ‫ـ‬     ‫ـ‬                  ‫ـ‬
‫ﻣ ـﻦ اﻟﺨﺼ ـﺎﺋﺺ اﻟﻤﻮﺟ ـﻮدة ﻓ ـﻲ ﻣﺠﻤﻮﻋ ـﺔ اﻟﻄﺎﺑﻌ ـﺎت ‪ Printers‬ﺧﺎﺻ ـﻴﺔ اﺳ ـﻢ اﻟﻄﺎﺑﻌ ـﺔ‬
                                             ‫ـ‬         ‫ـ‬     ‫ـ‬            ‫ـ‬        ‫ـ‬
 ‫ـ‬        ‫ـ‬            ‫ـ‬       ‫ـ‬                     ‫ـ‬         ‫ـ‬
‫‪ DeviceName‬او اﺳ ـﻢ اﻟﻤﺸ ـﻐﻞ ‪ ،DeriverName‬رﻗ ـﻢ اﻟﻤﻨﻔ ـﺬ ‪ Port‬اﻟﻤﺮآ ـﺐ ﻋﻠﻴ ـﻪ‬
                                                                     ‫اﻟﻄﺎﺑﻌﺔ ....اﻟﺦ:‬

‫‪Dim X As Integer‬‬

‫اﺳﺘﺨﺪام اﻟﻤﺠﻤﻮﻋﺔ ‘‬
‫‪‘ Printers Collection‬‬
‫1- ‪For X = 0 To Printers.Count‬‬
   ‫‪Print Printers(X).DeviceName‬‬
‫‪Next‬‬

‫ﺑﻜﻞ ﺗﺄآﻴﺪ ﺗﻮد ﻣﻦ اﻟﻤﺴﺘﺨﺪم ﺗﺤﺪﻳﺪ اﻟﻄﺎﺑﻌﺔ اﻟﺘﻲ ﻳﺮﻳﺪ اﺳﺘﺨﺪاﻣﻬﺎ. آﻞ ﻣﺎ ﻋﻠﻴﻚ هﻮ‬
‫ﺗﻮﻓﻴﺮ آﻮد ﻣﻨﺎﺳﺐ ﻟﺘﻌﻴﻴﻦ اﻟﻄﺎﺑﻌـﺔ اﻟﻤﻮﺟـﻮدة ﻓـﻲ اﻟﻤﺠﻤﻮﻋـﺔ ‪ Printers‬اﻟـﻰ اﻟﻜـﺎﺋﻦ‬
                           ‫‪ .Printer‬هﺬا ﻣﺜﺎل ﻟﻌﻤﻞ ذﻟﻚ ﺑﺎﺳﺘﺨﺪام اﻻداة ‪:ListBox‬‬

‫)(‪Private Sub Form_Load‬‬
  ‫‪Dim X As Integer‬‬

‫اﺳﺘﺨﺪام اﻟﻤﺠﻤﻮﻋﺔ ‘‬
‫‪‘ Printers Collection‬‬
   ‫1- ‪For X = 0 To Printers.Count‬‬
     ‫‪List1.AddItem Printers(X).DeviceName‬‬
   ‫‪Next‬‬
‫‪End Sub‬‬

‫)(‪Private Sub List1_Click‬‬
‫ﺗﺤﺪﻳﺪ اﻟﻄﺎﺑﻌﺔ ﻣﻦ اﻟﻤﺠﻤﻮﻋﺔ ‘‬
   ‫)‪Set Printer = Printers(List1.ListIndex‬‬
‫‪End Sub‬‬
                                             ‫441‬


‫واﻻن آﻞ ﻣﺎ ﻋﻠﻴﻚ هﻮ اﺳﺘﺨﺪام اﻟﻜﺎﺋﻦ ‪ Printer‬ﻟﺘﻌـﺪﻳﻞ ﺧﺼـﺎﺋﺺ اﻟﻄﺎﺑﻌـﺔ اﻟﺤﺎﻟﻴـﺔ او‬
‫اﻟﺒﺪء ﻓﻲ ﻋﻤﻠﻴﺔ اﻟﻄﺒﺎﻋﺔ. ﻣﻦ هﺬﻩ اﻟﺨﺼﺎﺋﺺ، ﺧﺎﺻﻴﺔ ‪ ColorMode‬اﻟﺘـﻲ ﺗﻌـﺮف ﻋـﻦ‬
‫ﻃﺮﻳﻘﻬﺎ ﻣﺎ اذا آﺎﻧﺖ اﻟﻄﺎﺑﻌـﺔ داﻋﻤـﺔ ﻟﻼﻟـﻮان ام ﻻ. واﻟﺨﺎﺻـﻴﺔ ‪ PrinterQuality‬واﻟﺘـﻲ‬
‫ﺗﻌﻮد ﺑﻨﻮع اﻟﻜﺜﺎﻓﺔ اﻟﻨﻘﻄﻴﺔ وﺟﻮدة اﻟﻄﺒﺎﻋﺔ. اﻟﺨﺼﺎﺋﺺ اﻻﺧﺮى ﺗﺠـﺪهﺎ ﺑﺸـﻜﻞ ﻣﻔﺼـﻞ‬
                                                               ‫ﻓﻲ ﻣﻜﺘﺒﺔ ‪.MSDN‬‬
‫اﻣﺎ ﻋﻤﻠﻴﺔ اﻟﻄﺒﺎﻋﺔ اﻟﻔﻌﻠﻴﺔ ﻓﺘﺘﻢ ﺑﺎﺳﺘﺨﺪام ﻃﺮق آﺎﺋﻦ اﻟﻄﺎﺑﻌـﺔ وهـﻲ ﻧﻔـﺲ اﻟﻄـﺮق‬
‫اﻟﻤﻮﺟﻮدة ﻓﻲ آـﺎﺋﻦ اﻟﻨﻤـﻮذج ‪ .... Cirlce ،Line ،Print‬اﻟـﺦ واﺳـﺘﺨﺪاﻣﻬﺎ ﻳـﺘﻢ ﺑـﻨﻔﺲ‬
‫اﻟﻄﺮﻳﻘﺔ اﻟﺘﻲ اﺳﺘﺨﺪﻣﻨﺎهﺎ ﻣﻊ ﻧﺎﻓﺬة اﻟﻨﻤﻮذج ﻓﻲ اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ "اﻟﻨﻤـﺎذج واﻻدوات".‬
‫ﺑﻌﺪ ان ﺗﻨﺘﻬﻲ ﻣﻦ ارﺳـﺎل اﻟﺒﻴﺎﻧـﺎت اﻟـﻰ اﻟﻄﺒﺎﻋـﺔ، اﺳـﺘﺨﺪم اﻟﻄﺮﻳﻘـﺔ ‪ EndDoc‬ﻟﺒـﺪء‬
                                                          ‫ﻋﻤﻠﻴﺔ اﻟﻄﺒﺎﻋﺔ اﻟﻔﻌﻠﻴﺔ:‬

‫‪Printer.RightToLeft =True‬‬
‫04 = ‪Printer.FontSize‬‬
‫”ﺗﺮآﻲ اﻟﻌﺴﻴﺮي“ ‪Printer.Print‬‬
‫اﺑﺪأ ﻋﻤﻠﻴﺔ اﻟﻄﺒﺎﻋﺔ ‘‬
‫‪Print.EndDoc‬‬

‫اﻟﻄﺮﻳﻘﺔ ‪ KillDoc‬ﺗﻘﻮم ﺑﺎﻧﻬﺎء ﻋﻤﻠﻴﺔ اﻟﻄﺒﺎﻋﺔ، واﻟﻄﺮﻳﻘﺔ ‪ NewPage‬واﺿﺢ ﻣـﻦ اﺳـﻤﻬﺎ‬
                                                   ‫اﻧﻬﺎ ﺗﺨﺮج ﺻﻔﺤﺔ ﺟﺪﻳﺪة.‬


                                                               ‫اآﺘﺸﺎف اﻻﺧﻄﺎء‬
‫ﻣﻤــﺎ ﻻ ﺷــﻚ ﻓﻴــﻪ، ان ﻣــﻦ اهــﻢ اﺳــﺒﺎب اﻧﺘﺸــﺎر اﻟﺸــﻌﻴﺮات اﻟﺒﻴﻀــﺎء ﻓــﻲ رؤوس‬
‫اﻟﻤﺒﺮﻣﺠﻴﻦ هﻲ اﻻﺧﻄﺎء اﻟﺒﺮﻣﺠﻴﺔ. ﻓﻜﻢ ﻣﻦ ﻣﺒﺮﻣﺞ آﺴﺮ ﺷﺎﺷﺔ ﺟﻬﺎزﻩ ﺑﺴﺒﺐ آﺜـﺮة‬
‫اﻻﺧﻄﺎء ﻏﻴﺮ اﻟﻤﺘﺪارآﺔ ﻓﻲ ﺑﺮﻧﺎﻣﺠـﻪ، وآـﻢ ﻣـﻦ ﻣﺒـﺮﻣﺞ ﺗﻮﻗـﻒ ﻋـﻦ إآﻤـﺎل ﻣﺸـﺎرﻳﻌﻪ‬
‫ﺑﺴﺒﺐ ﻋﺪم ﻣﻌﺮﻓﺔ ﻣﺼﺪر اﻟﺨﻄﺄ. آﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ دون اﺧﻄﺎء ﺷﻲء ﻳﺘﺤﻘﻖ ﻓـﻲ اﻟﺨﻴـﺎل‬
              ‫ﻓﻘﻂ! ﻟﻜﻦ آﻠﻤﺎ زادت اﺣﺘﻴﺎﻃﺎﺗﻚ ﻟﺘﻔﺎدي اﻻﺧﻄﺎء ﻗﻠﺖ ﻧﺴﺒﺔ ﻇﻬﻮرهﺎ.‬

                                                                  ‫ﻓﻜﺮة ﻋﺎﻣﺔ‬
‫ﺗﺼﻨﻒ اﻻﺧﻄﺎء ﻓﻲ أي ﻟﻐﺔ ﺑﺮﻣﺠﺔ اﻟﻰ ﺻﻨﻔﻴﻦ ﻋﻠـﻰ اﺳـﺎس وﻗـﺖ ﺣـﺪوﺛﻬﺎ اﻣـﺎ ﻓـﻲ‬
‫وﻗﺖ اﻟﺘﺼﻤﻴﻢ او وﻗﺖ اﻟﺘﻨﻔﻴﺬ. هﺬﻩ اﻻﺧﻄـﺎء ﺗﺴـﺒﺐ اﻧﻬﻴـﺎر ﺑﺮﻧﺎﻣﺠـﻚ واﻧﻬـﺎء ﺗﻨﻔﻴـﺬﻩ.‬
‫ﺑﺎﻻﺿﺎﻓﺔ اﻟﻰ ذﻟﻚ، ﻳﻮﺟﺪ ﻧﻮع ﻣـﻦ اﻻﺧﻄـﺎء اﻟﺘـﻲ ﻻ ﺗﻈﻬـﺮ ﻟـﻚ ﺑﺸـﻜﻞ ﻣﺒﺎﺷـﺮ ﺗﻌـﺮف‬
                                   ‫ﺑﺎﻟﺸﻮاﺋﺐ ‪ .Bugs‬ﻟﻨﻠﻘﻲ ﻧﻈﺮة ﻋﻠﻰ هﺬﻩ اﻻﺻﻨﺎف:‬
                                                  ‫541‬


                                  ‫اﺧﻄﺎء وﻗﺖ اﻟﺘﺼﻤﻴﻢ ‪:Design Time Errors‬‬
‫وﺗﻌﺮف اﻳﻀﺎ ﺑﺎﻻﺧﻄﺎء اﻟﻨﺤﻮﻳـﺔ ‪ Syntax Errors‬وهـﻲ اﺳـﻬﻞ اﻧـﻮاع اﻻﺧﻄـﺎء اآﺘﺸـﺎﻓﺎ‬
‫واﺻﻼﺣﺎ. وﻗﺖ ﺣﺪوث هﺬﻩ اﻻﺧﻄﺎء ﻳﻜﻮن ﻓﻲ ﻣﺮﺣﻠﺔ اﻟﺘﺼـﻤﻴﻢ او اﻟﺘﺮﺟﻤـﺔ ﻟﻠﺒﺮﻧـﺎﻣﺞ.‬
‫ﺳﺒﺒﻬﺎ اﻟﺮﺋﻴﺴﻲ ﻓﻲ ﻃﺮﻳﻘﺔ آﺘﺎﺑﺔ اﻟﻌﺒﺎرات اﻟﺒﺮﻣﺠﻴﺔ اﻟﺨﺎﻃﺌﺔ. ﻓﻤﺜﻼ ﻗﺪ ﺗﻜﺘـﺐ اﺳـﻢ‬
            ‫داﻟﺔ ﻟﻴﺴﺖ ﻣﻮﺟﻮدة، او ﺗﻨﺸﺊ ﺣﻠﻘﺔ ‪ For‬ﺑﺪون اﻗﻔﺎﻟﻬﺎ ﺑﺎﺳﺘﺨﺪام ‪.Next‬‬
‫ﺗﻮﻓﺮ ﻟﻚ ﺑﻴﺌﺔ اﻟﺘﻄﻮﻳﺮ اﻟﻤﺘﻜﺎﻣﻠﺔ ﻟـ ‪ Visual Basic‬ﺗﻘﻨﻴﺔ ﻓﻲ ﻗﻤﺔ اﻟﺮوﻋـﺔ هـﺪﻓﻬﺎ ﻗـﻨﺺ‬
‫هﺬﻩ اﻻﺧﻄﺎء ﺗﻠﻘﺎﺋﻴﺎ ﺑﻤﺠﺮد اﻟﻮﻗﻮع ﻓﻴﻬﺎ وذﻟـﻚ ﺑﻌـﺪ اﻟﻀـﻐﻂ ﻋﻠـﻰ اﻟﻤﻔﺘـﺎح ]‪.[ENTER‬‬
‫ﻣﺜﻼ، ﻗﻢ ﺑﻜﺘﺎﺑﺔ 4 == ‪ X‬واﺿﻐﻂ ﻣﻔﺘﺎح ]‪ [ENTER‬ﺳﺘﻼﺣﻆ ﻇﻬـﻮر رﺳـﺎﻟﺔ ﺗﻮﺿـﺢ ﻟـﻚ‬
‫اﻟﺨﻄﺄ وﻗﺪ ﻗﻠﺐ ﻟﻮن اﻟﺴﻄﺮ ﺑﺎﻻﺣﻤﺮ. ﺗﻌﺮف هﺬﻩ اﻟﺘﻘﻨﻴـﺔ ﺑﺎﻟﺘـﺪﻗﻴﻖ اﻟﻨﺤـﻮي اﻟﺘﻠﻘـﺎﺋﻲ‬
‫‪ Auto Syntax Check‬واﻟﺘـﻲ ﺗﺴـﺘﻄﻴﻊ اﻟﻐﺎﺋﻬـﺎ ﻋـﻦ ﻃﺮﻳـﻖ اﻻﺧﺘﻴـﺎر ‪Auto Syntax‬‬
‫‪ Check‬اﻟﻤﻮﺟﻮد ﻓﻲ ﺧﺎﻧﺔ اﻟﺘﺒﻮﻳﺐ ‪ Editor‬ﻓﻲ ﻧﺎﻓﺬة اﻟﺨﻴﺎرات ‪ .Options‬ﻻ اﻋﺘﻘﺪ اﻧـﻚ‬
                                            ‫ﺳﺘﻠﻐﻴﻬﺎ ﻳﻮﻣﺎ ﻣﻦ اﻻﻳﺎم اﻟﻴﺲ آﺬﻟﻚ؟!‬

                                      ‫اﺧﻄﺎء وﻗﺖ اﻟﺘﻨﻔﻴﺬ ‪:Run Time Errors‬‬
‫وﻗﺖ ﻇﻬﻮر هﺬﻩ اﻻﺧﻄﺎء ﻣﺨﺘﻠﻒ. ﻓﻠﻦ ﺗﻈﻬﺮ اﻟﺮﺳﺎﻟﺔ اﻟﻤﺰﻋﺠـﺔ اﻟﺴـﺎﺑﻘﺔ وﻗـﺖ آﺘﺎﺑـﺔ‬
‫اﻟﻜﻮد واﻧﻤﺎ ﻓﻲ وﻗﺖ اﻟﺘﻨﻔﻴـﺬ. ﻋﻨـﺪﻣﺎ ﻳﺼـﻞ اﻟﻤﻔﺴـﺮ ﻋﻨـﺪ ﺳـﻄﺮ ﺻـﺤﻴﺢ ﻧﺤﻮﻳـﺎ ﻟﻜﻨـﻪ‬
‫ﺧﺎﻃﺊ ﻣﻨﻄﻘﻴﺎ ﺳﺘﻈﻬﺮ رﺳﺎﻟﺔ ﺧﻄـﺄ ﺑﻌﻨـﻮان ‪ Run Time Error‬وﻳﻈﻬـﺮ ﺗﺤﺪﻳـﺪ ﻟﻤﻜـﺎن‬
                               ‫اﻟﺴﻄﺮ اﻟﺬي وﻗﻊ ﻓﻴﻪ اﻟﺨﻄﺄ. ﻣﺜﻼ اآﺘﺐ هﺬا اﻟﻜﻮد:‬

‫‪Dim X As Byte‬‬
‫652 = ‪X‬‬

‫ﻣﻦ اﻟﻮاﺿﺢ ان اﻟﺼﻴﻐﺔ اﻟﻨﺤﻮﻳﺔ ﻟﻬﺬا اﻟﻜﻮد ﺻﺤﻴﺤﺔ ﻟﻜﻦ ﻣـﻦ اﻟﻨﺎﺣﻴـﺔ اﻟﻤﻨﻄﻘﻴـﺔ ﺧﻄـﺄ.‬
‫ﺟــﺮب ﺗﻨﻔﻴــﺬ اﻟﺒﺮﻧــﺎﻣﺞ وﺳــﺘﻼﺣﻆ ﻇﻬــﻮر رﺳــﺎﻟﺔ ﺧﻄــﺄ ‪ OverFlow‬وذﻟــﻚ ﻻن اﻟﻘﻴﻤــﺔ‬
‫اﻟﻘﺼﻮى اﻟﺘﻲ ﻳﻤﻜﻦ ان ﻳﺤﻤﻠﻬﺎ أي ﻣﺘﻐﻴﺮ ﻣﻦ ﻧﻮع ‪ Byte‬هﻲ 552. ﻃﺒﻌﺎ اﺧﻄـﺎء وﻗـﺖ‬
‫اﻟﺘﻨﻔﻴــﺬ آﺜﻴــﺮة ﺟــﺪا ﺟــﺪا، ﻓﺎﻧــﺖ ﻋﻨــﺪﻣﺎ ﺗﺼــﻤﻢ اﻟﺒﺮﻧــﺎﻣﺞ ﺗﺘﻮﻗــﻊ ان آــﻞ اﻻﺣﺘﻤــﺎﻻت‬
‫اﻟﺨﺎرﺟﻴﺔ آﻤﺎ هﻲ ﻓﻲ ﺣﺎﻟﺔ ﺗﺼﻤﻴﻢ اﻟﺒﺮﻧﺎﻣﺞ. ﻣﺜﻼ ﻟﻮ وﺟـﺪ ﻓـﻲ اﺣـﺪ ﺳـﻄﻮر ﺑﺮﻧـﺎﻣﺞ‬
                                       ‫اﻣﺮ ﻳﻘﻮم ﺑﻤﺴﺢ ﻣﻠﻒ ﻣﻌﻴﻦ وآﺘﺒﺖ هﺬا اﻟﻜﻮد:‬

‫” ‪Kill “FileName.EXT‬‬

‫ﻗﺪ ﻋﻤﻞ ﻣﻌﻚ ﺑﺎﻟﺸﻜﻞ اﻟﻤﻄﻠﻮب، ﻟﻜﻦ اﻓﺘﺮض ان اﻟﻤﻠﻒ ﻟﻢ ﻳﻜﻦ ﻣﻮﺟﻮد؟ ﻓـﺎن رﺳـﺎﻟﺔ‬
‫اﻟﺨﻄﺄ ﺳﻴﻜﻮن ﻟﻬﺎ ﻧﺼﻴﺐ ﻣﻦ ﻋﻤﺮ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ. ﻓﻠﻮ آﻨﺖ ذآﻴـﺎ ﺳـﺘﺘﺄآﺪ ﻣـﻦ وﺟـﻮد‬
                                       ‫اﻟﻤﻠﻒ ﺑﺎﺳﺘﺨﺪام داﻟﺔ ‪ Dir‬وﻣﻦ ﺛﻢ ﺣﺬﻓﻪ:‬
                                                ‫641‬


‫” ‪If Dir$(“FileName.EXT”) Then Kill “FileName.EXT‬‬

‫ﻳﺒﺪو ان ذآﺎﺋﻚ ﺧﺎرق ﺟﺪا ﻳﺎ ﻗﺎرئ هﺬﻩ اﻟﺴﻄﻮر ﻟﻜﻦ ﻣﻬﻼ آﺎﺗـﺐ هـﺬﻩ اﻟﺴـﻄﻮر ﻟﺪﻳـﻪ‬
‫ﺷﺊ اﺧﺮ ﻟﻴﺨﺒﺮك ﺑﻪ. ﻣﺎذا ﻟﻮ آﺎن اﻟﻤﻠﻒ ﻣﻮﺟﻮد ﻟﻜﻦ ﺧﺎﺻﻴﺔ ‪ ReadOnly‬ﻣﺪﻋﻮﻣـﺔ ﺑـﻪ‬
‫أي اﻧﻪ ﻏﻴﺮ ﻗﺎﺑﻞ ﻟﻠﺤﺬف؟؟ ارأﻳﺖ رﺳﺎﻟﺔ اﻟﺨﻄﺄ ﺳـﺘﻈﻬﺮ ﻣـﻦ ﺟﺪﻳـﺪ. اذن ﺳﺘﺴـﺘﺨﺪم‬
    ‫ذآﺎﺋﻚ اﻟﺨﺎرق وﺗﺘﺄآﺪ ﻣﻦ وﺟﻮد اﻟﻤﻠﻒ وﻣﻦ ﺛﻢ ﻣﻦ ﻋﺪم وﺟﻮد ﺧﺎﺻﻴﺔ ‪:ReadOnly‬‬

‫‪If Dir$(“FileName.EXT”) Then‬‬
   ‫‪If Not (GetAttr("FileName.EXT”) And vbReadOnly) Then‬‬
      ‫”‪Kill “FileName.EXT‬‬
   ‫‪End If‬‬
‫‪End If‬‬

‫ﺣﺴﻨﺎ ﻳﺎ ﻗﺎرﺋﻲ اﻟﻔﺎﺿـﻞ، ﻟـﻚ ﻣﻨـﻲ ﻓـﺎﺋﻖ اﻟﺘﻘـﺪﻳﺮ واﻻﺣﺘـﺮام ﻋﻠـﻰ ﻣﺤﺎوﻟﺘـﻚ اﻟﺮاﺋﻌـﺔ‬
  ‫ـ‬            ‫ـ‬   ‫ـ‬        ‫ـ‬
‫ﻟﺘﺠﻨـﺐ اﻟﺨﻄـﺄ ﻟﻜـﻦ ﻣـﻊ ذﻟـﻚ ﻓﻬﻨـﺎك اﺣﺘﻤـﺎل اﺧـﺮ ﻟﻮﻗـﻮع اﻟﺨﻄـﺄ! اﻓﺘـﺮض ان اﻟﻤﻠـﻒ‬
                                 ‫ـ‬     ‫ـ‬        ‫ـ‬     ‫ـ‬    ‫ـ‬   ‫ـ ـ‬
‫‪ FileName.EXT‬ﻳﺘﻢ اﺳﺘﺨﺪاﻣﻪ ﻣﻦ ﻗﺒﻞ ﺑﺮﻧـﺎﻣﺞ اﺧـﺮ ‪ Process‬وآﺎﻧـﺖ ﻋﻠﻴـﻪ ﺧﺎﺻـﻴﺔ‬
‫اﻻﻗﻔﺎل -أي ﻣﺴﻤﻮح ﻟﻠﺒﺮﻧﺎﻣﺞ اﻟﺬي ﻳﺴﺘﺨﺪﻣﻪ ﻓﻘﻂ- ﻓﺎﻧﻚ ﻟـﻦ ﺗﺴـﺘﻄﻴﻊ ﻓـﺘﺢ اﻟﻤﻠـﻒ‬
          ‫وﺳﺘﻈﻬﺮ رﺳﺎﻟﺔ اﻟﺨﻄﺄ اﻟﺘﻲ اﺧﺒﺮﺗﻚ ﺑﻬﺎ واآﻮن ﻗﺪ ﻏﻠﺒﺘﻚ ﻓﻲ هﺬا اﻟﺘﺤﺪي.‬
‫اﻟﻘﻀﻴﺔ ﻟﻴﺴﺖ ﻣﻦ ﻳﻐﻠﺐ ﻣﻦ، ﻓﻜﻠﻨﺎ ﻣﺒﺮﻣﺠﻴﻦ ﻧﻨﺴﻰ آﺜﻴﺮا. ﻟﻜﻦ ﻻﺑﺪ ﻷي ﻣﺒﺮﻣﺞ ﻣﻦ‬
    ‫وﺿﻊ ﺟﻤﻴﻊ وآﺎﻓﺔ اﻻﺣﺘﻤﺎﻻت اﻟﻤﻤﻜﻨﺔ ﻟﺘﻔﺎدي وﺗﺠﻨﺐ اﻻﺧﻄﺎء آﻤﺎ ﺳﻨﺮى ﻻﺣﻘﺎ.‬

                                                                   ‫اﻟﺸﻮاﺋﺐ ‪:Bugs‬‬
‫ﻗﺪ ﻳﻜﻮن اﻟﻜﻮد ﺳﻠﻴﻢ ﻣﻦ ﻧﺎﺣﻴﺔ ﻧﺤﻮﻳﺔ وﻻ ﺗﻮﺟﺪ ﺑﻪ أي اﺧﻄﺎء ﻓﻲ وﻗـﺖ اﻟﺘﻨﻔﻴـﺬ ﻟﻜـﻦ‬
‫ﺑﻪ ﺷﻮاﺋﺐ. ﻻ ﻳﻮﺟﺪ ﺑﺮﻧﺎﻣﺞ اﻻ وﺑﻪ ﺷﻮاﺋﺐ. اﻟﺸﻮاﺋﺐ هﻲ اﺧﻄـﺎء ﻓـﻲ ﺳـﻠﻮك ﺗﻨﻔﻴـﺬ‬
‫اﻟﺒﺮﻧﺎﻣﺞ ﻟﻜﻨﻬﺎ ﻻ ﺗﺴﺒﺐ ﻓﻲ اﻳﻘﺎﻓـﻪ، وهـﻲ ﺻـﻌﺒﺔ اﻻﻳﺠـﺎد واﻻآﺘﺸـﺎف. ﻟـﺬﻟﻚ، ﺗﺠـﺪ‬
‫ﻏﺎﻟﺒﺎ ﻓﻲ اﻟﺒﺮاﻣﺞ اﻟﺘﺠﺎرﻳﺔ اﻟﻜﺒﻴـﺮة ﺻـﺪور ﻧﺴـﺦ ﺗﺠﺮﻳﺒﻴـﺔ ‪ Beta‬ﺗـﻮزع ﻋﻠـﻰ اﺷـﺨﺎص‬
‫وﺷــﺮآﺎت ﻣﻌﻴﻨــﺔ اﻟﻬــﺪف ﻣﻨﻬــﺎ ﺗﺠﺮﺑــﺔ اﻟﺒﺮﻧــﺎﻣﺞ واﻟﺘﺤﻘــﻖ ﻣــﻦ واآﺘﺸــﺎف اﻟﺸــﻮاﺋﺐ‬
‫اﻟﻤﻮﺟﻮدة ﻓﻴـﻪ. ﻣـﻦ اآﺒـﺮ اﻻﺧﻄـﺎء اﻟـﺬي ﻳﻘـﻊ ﻓﻴﻬـﺎ اﻟﻤﺒـﺮﻣﺞ هـﻲ ﻣﺤﺎوﻟـﺔ اآﺘﺸـﺎف‬
‫اﻟﺸﻮاﺋﺐ ﺑﻨﻔﺴﻪ، ﻷﻧﻚ ﻟﻦ ﺗﺴﺘﻄﻴﻊ اآﺘﺸﺎف اﻟﺸـﻮاﺋﺐ اﻻ ﻋـﻦ ﻃﺮﻳـﻖ ﻏﻴـﺮك، ﻓﻔـﻲ‬
‫ﺣﺎﻟﺔ ﺗﺠﺮﺑﺔ ﺑﺮاﻣﺠﻚ اﻟﺸﺨﺼﻴﺔ ﻓﺎﻧﻚ اآﺜﺮ ﻣﻦ ﻳﻌﺮف ﻃﺮﻳﻘﺔ اﻟﺘﻌﺎﻣـﻞ ﻣﻌﻬـﺎ، ﻟﻜـﻦ ﻓـﻲ‬
‫ﺣﺎﻟﺔ وﺟﻮد ﻧﺴﺨﺔ ﻣﻦ اﻟﺒﺮﻧـﺎﻣﺞ ﻋﻨـﺪ ﺷـﺨﺺ اﺧـﺮ ﻓﺎﻟﻮﺿـﻊ ﻳﺨﺘﻠـﻒ، وﺗﺒـﺪأ اﻟﺸـﻮاﺋﺐ‬
                                                                          ‫ﺑﺎﻟﻈﻬﻮر ﻟﺪﻳﻪ.‬
‫‪ Visual Basic‬ﺑﻪ ﺷﻮاﺋﺐ. هﻨﺎك اﻟﻜﺜﻴـﺮ ﻣـﻦ اﻟﺸـﻮاﺋﺐ اﻟﺘـﻲ ﺗﻜﺘﺸـﻒ ﺷـﻬﺮﻳﺎ وﺗﺼـﺪر‬
‫ﺷﺮآﺔ ‪ Microsoft‬ﺗﻘﺎرﻳﺮ ﻋﻨﻬـﺎ ﺗﺠـﺪهﺎ ﺑﺸـﻜﻞ دوري ﻓـﻲ ﻣﻜﺘﺒـﺔ ‪ ،MSDN‬ﺑﻌﻀـﻬﺎ ﺗـﻢ‬
                                             ‫741‬


‫اﺻﻼﺣﻪ واﻟـﺒﻌﺾ اﻻﺧـﺮ ﻻ. اﻟﻤﻘﺼـﺪ ﻣـﻦ هـﺬا اﻟﻜـﻼم، اﻧـﻪ ﻣﻬﻤـﺎ آـﺎن ﻣﺴـﺘﻮاك ﻓـﻲ‬
                                     ‫اﻟﺒﺮﻣﺠﺔ ﻻﺑﺪ ﻣﻦ وﺟﻮد ﺷﻮاﺋﺐ ﻓﻲ ﺑﺮﻧﺎﻣﺠﻚ.‬
‫ﻳﻮﺟﺪ اﻟﻜﺜﻴﺮ ﻣﻦ اﻟﻜﺘﺐ اﻟﺘﻲ ﺗﻨﺎﻗﺶ ﻣﺴﺄﻟﺔ اﻟﺸﻮاﺋﺐ اﻟﺒﺮﻣﺠﻴﺔ وآﻴﻔﻴﺔ ﺗﻔﺎدﻳﻬﺎ -اﻗﺼﺪ‬
                                  ‫اﻻﻗﻼل ﻣﻨﻬﺎ- اﻻ اﻧﻬﺎ ﻣﻮاﺿﻴﻊ ﺧﺎرج ﻧﻄﺎق اﻟﻜﺘﺎب.‬

                                                                   ‫اﻟﻜﺎﺋﻦ ‪Err‬‬
‫ﻋﻮدا اﻟﻰ ﻣﻮﺿﻮع اﺧﻄﺎء وﻗﺖ اﻟﺘﺸﻐﻴﻞ وﺑﺎﻟﺘﺤﺪﻳﺪ ﻓﻲ ﻣﺜـﺎل اﻟﻤﻠـﻒ ‪،FileName.EXT‬‬
‫ﺑﺪﻻ ﻣﻦ آﺘﺎﺑﺔ ﻋﺸﺮات اﻻﺳﻄﺮ ﻟﻠﺘﺄآﺪ ﻣﻦ ﻗﺎﺑﻠﻴﺔ ﺣﺬف اﻟﻤﻠﻒ، اﺳﺘﺨﺪم آﺎﺋﻦ اﻟﺨﻄـﺄ‬
‫‪ .Err‬ﻗﺒﻞ ﺗﻄﺒﻴﻖ هﺬا اﻟﻜﺎﺋﻦ، ﻋﻠﻴﻚ ﻣﻌﺮﻓﺔ أن آﻞ ﺧﻄﺄ ﻣﻦ اﺧﻄﺎء وﻗـﺖ اﻟﺘﺸـﻐﻴﻞ ﻟـﻪ‬
‫رﻗﻢ ﺧﺎص ﻳﻤﻴﺰة ﻋﻦ ﻏﻴﺮة ﻣﻦ اﻻﺧﻄﺎء ﺑﻪ وآﺬﻟﻚ وﺻﻒ ﻧﺼـﻲ ﻣﺨﺘﺼـﺮ ﻟﻠﺨﻄـﺄ، وﻋﻨـﺪ‬
‫ﺣﺪوث اﻟﺨﻄﺄ ﻳﺘﻢ وﺿﻊ هﺬﻩ اﻟﺒﻴﺎﻧﺎت -اﻟﺨﺎﺻﺔ ﺑﺎﻟﺨﻄـﺄ- ﻓـﻲ اﻟﻜـﺎﺋﻦ ‪ .Err‬ﻋﻨـﺪ رﻏﺒﺘـﻚ‬
‫ﻓﻲ اﻻﺳﺘﻤﺮار ﻓﻲ ﻋﻤﻠﻴـﺔ ﺗﻨﻔﻴـﺬ اﻟﺒﺮﻧـﺎﻣﺞ ﺣﺘـﻰ ﻋﻨـﺪ وﻗـﻮع اﻟﺨﻄـﺄ ﻻﺑـﺪ ﻣـﻦ آﺘﺎﺑـﺔ‬
‫اﻟﺘﻌﻠﻴﻤﺔ ‪ On Error Resume Next‬ﻋﻨﺪ ﺑﺪاﻳﺔ آﻞ اﺟﺮاء ﺗﺘﻮﻗﻊ ﺣﺪوث ﺧﻄﺄ ﻓﻴـﻪ ﺣﺘـﻰ‬
                                ‫ﻳﺴﺘﻤﺮ ﻓﻲ ﺗﻨﻔﻴﺬ ﺳﻄﻮر اﻟﺒﺮﻧﺎﻣﺞ راﻗﺐ هﺬا اﻟﻤﺜﺎل:‬

‫‪On Error Resume Next‬‬

‫”‪Kill “FileName.EXT‬‬
‫‪If Err Then‬‬
   ‫‪MsgBox Err.Description‬‬
   ‫‪Err.Clear‬‬
‫‪End If‬‬

‫هﻨﺎ ﺳﻨﻘﻮم ﺑﻤﺤﺎوﻟﺔ ﺣﺬف اﻟﻤﻠﻒ، ان ﻟﻢ ﻳﺴﺘﻄﻊ اﻟﺒﺮﻧﺎﻣﺞ ﻓﻌﻞ ذﻟﻚ ﻓـﺎن اﻟﻜـﺎﺋﻦ ‪Err‬‬
‫ﺳﻴﺤﺘﻮي ﻋﻠﻰ ﺧﺼﺎﺋﺺ ﺗﺘﻌﻠﻖ ﺑﺬﻟﻚ اﻟﺨﻄﺄ وﺳﻨﻈﻬﺮ رﺳﺎﻟﺔ ﺗﻮﺿﺢ وﺻﻒ اﻟﺨﻄﺄ. ﻣـﻦ‬
‫اﻟﻤﻬﻢ اﻟﺘﺄآﺪ ﻣﻦ ﺗﻨﻈﻴﻒ اﻟﻜﺎﺋﻦ ‪ Err‬ﻋﻦ ﻃﺮﻳﻖ اﺳـﺘﺪﻋﺎء اﻟﻄﺮﻳﻘـﺔ ‪ Clear‬ﺣﺘـﻰ ﻧﺨﺒـﺮ‬
                          ‫اﻟﺒﺮﻧﺎﻣﺞ اﻧﻨﺎ اﻧﺘﻬﻴﻨﺎ ﻣﻦ ﻗﻨﺺ اﻟﺨﻄﺄ واﻧﻪ ﻻ ﻳﻮﺟﺪ ﺧﻄﺄ اﺧﺮ.‬
‫اﻣﺎ اذا آﺎﻧـﺖ اآـﻮاد اﻻﺟـﺮاء ﻃﻮﻳﻠـﺔ وﻻ ﺗـﻮد ان ﺗﻜﺘـﺐ اﻟﺠﻤﻠـﺔ اﻟﺸـﺮﻃﻴﺔ ‪If Err Then‬‬
‫ﻣﺮات ﻣﺘﻌﺪدة، ﻓﻴﻔﻀﻞ اﺳﺘﺨﺪام ‪ On Error Goto X‬واﻟﺘـﻲ ﺗـﺆدي اﻟـﻰ اﻻﻧﺘﻘـﺎل اﻟـﻰ‬
                      ‫ﺳﻄﺮ ﻣﻌﻴﻦ ﻓﻲ ﺣﺎل ﺣﺪوث أي ﺧﻄﺄ ﻓﻲ ﺗﻨﻔﻴﺬ اآﻮاد اﻻﺟﺮاء:‬
                               148


Sub LongSub ()
      On Error Goto X:

      …
      …
      …

X:
      MsgBox Err.Description
      Err.Clear
End Sub
                                           ‫941‬


                                   ‫اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ‬
               ‫اﻟﺒﺮﻣﺠﺔ آﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ ‪OOP‬‬


‫ﻋ ّﻓﺖ اﻻﺻﺪارات 1‪ VB2 ،VB‬و 3‪ VB‬ان ‪ Visual Basic‬هـﻲ ﻟﻐـﺔ ﺑﺮﻣﺠـﺔ ﻣﺒﻨﻴـﺔ ﻋﻠـﻰ‬    ‫ﺮ‬
‫اﻟﻜﺎﺋﻨﺎت ‪– Object Based Programming Language‬ﺗﺨﺘﺼﺮ ‪ ،OBP‬اﻣﺎ ﻧﻘﻄﺔ اﻟﺘﺤـﻮل‬
‫آﺎﻧﺖ ﻣﻨﺬ اﻧﻄﻼق اﻻﺻﺪار 4‪ VB‬واﻟﺬي ﻣﻜﻨﻨﺎ ﻣﻦ اﻋﺘﺒﺎر ‪ Visual Basic‬ﻋﻠـﻰ اﻧﻬـﺎ ﻟﻐـﺔ‬
‫ﺑﺮﻣﺠﺔ آﺎﺋﻨﻴـﺔ اﻟﺘﻮﺟـﻪ ‪– Object Oriented Programming Language‬ﺗﺨﺘﺼـﺮ ‪-OOP‬‬
‫ﺑﻌﺪ اﺿﺎﻓﺔ ﻣﻴﺰة ﺗﻌﺮﻳﻒ اﻟﻔﺌﺎت ‪ Classes‬ﻋﻠﻰ هﺬﻩ اﻟﻠﻐﺔ، اﻻ ان اﻟﺒﻌﺾ ﻳﻌﺘـﺮض ﻋﻠـﻰ‬
‫وﺻﻒ ‪ Visual Basic‬ﺑﺎﻧﻬﺎ ‪ OOP‬ﻟﻌﺪم دﻋﻤﻬﺎ ﻟـﺒﻌﺾ اﻟﻤﻴـﺰات اﻻﺳﺎﺳـﻴﺔ ﻟﻠﻐـﺎت ‪OOP‬‬
‫آﺎﻟﻮراﺛﺔ ‪ ،Inheritance‬إﻋﺎدة اﻟﺘﻌﺮﻳﻒ ‪ .... OverLoading‬اﻟﺦ، ﻣـﻦ ﻧﺎﺣﻴـﺔ اﺧـﺮى ﻓﻬـﻮ‬
‫ﻳﺪﻋﻢ اﻟﻤﺒﺪأ اﻻﺳﺎﺳﻲ ﻟﻠﻐﺎت ‪ OOP‬وهﻮ اﻟﺘﻐﻠﻴﻒ ‪ Encapsulation‬ﻋﻦ ﻃﺮﻳـﻖ ﺗﻌﺮﻳـﻒ‬
                                           ‫اﻟﻔﺌﺎت ‪ Classes‬واﻟﻮاﺟﻬﺎت ‪.Interfaces‬‬
‫ﺧﻼﺻﺔ اﻟﻘﻮل، ‪ Visual Basic‬ﻻ ﻳﻌﺘﺒﺮ ﻟﻐﺔ آﺎﺋﻨﻴﺔ اﻟﺘﻮﺟـﻪ ‪ OOP‬ﺣﻘﻴﻘﻴـﺔ آﻠﻐـﺎت ++‪،C‬‬
‫‪ SmallTalk‬او ‪ ،JAVA‬وﻟﻜﻨﻪ ﻳﻤﻜﻨﻚ ﻣﻦ ﻣﺤﺎآﺎة ﻟﻐـﺎت ‪ OOP‬وﺗﻄﺒﻴـﻖ ﻣﻌﻈـﻢ ﻣﺒﺎدﺋﻬـﺎ.‬
‫وﻣﻦ ﻣﻨﻄﻠﻖ ﻋﻨﻮان هﺬا اﻟﻜﺘﺎب "‪ Visual Basic‬ﻟﻠﺠﻤﻴﻊ - ﻧﺤﻮ ﺑﺮﻣﺠﺔ آﺎﺋﻨﻴـﺔ اﻟﺘﻮﺟـﻪ"،‬
‫ﻓﻬﺬا اﻟﻔﺼﻞ هﻮ ﻣﺪﺧﻠﻚ اﻟﺮﺋﻴﺲ اﻟﻰ اﻟﺒﺮﻣﺠﺔ آﺎﺋﻨﺔ اﻟﺘﻮﺟﻪ ‪ OOP‬وﺗﻄﺒﻴﻘﻬﺎ ﺑـ ‪Visual‬‬
      ‫‪ ،Basic‬وﺳﺘﻜﻮن ﺟﻤﻴﻊ اﻟﻔﺼﻮل اﻟﻼﺣﻘﺔ ﻣﻦ هﺬا اﻟﻜﺘﺎب ﻣﺒﻨﻴﺔ ﻋﻠﻰ هﺬا اﻟﻔﺼﻞ.‬
‫ﻧﻈﺮً ﻷن ﺟﻤﻴﻊ اﻟﻔﺼﻮل اﻟﻼﺣﻘﺔ ﻣﻦ هﺬا اﻟﻜﺘﺎب ﺳﺘﻜﻮن ﻣﺒﻨﻴﺔ ﻋﻠﻰ ﻣـﺎ ﺗﻌﻠﻤﺘـﻪ ﻣـﻦ‬   ‫ا‬
                      ‫هﺬا اﻟﻔﺼﻞ، ﻓﺎﻧﻲ ارﺟﻮ ﻣﻨﻚ أن ﺗﺘﻘﺒﻞ ﻣﻨﻲ هﺎﺗﻴﻦ اﻟﻨﺼﻴﺤﺘﻴﻦ:‬
‫- ﻻ ﺗﺤﺎول ﺗﺠـﺎوز إي ﻓﻘـﺮة. اذا ﺷـﻌﺮت أﻧـﻚ ﻏﻴـﺮ ﻣﺴـﺘﻮﻋﺐ ﻟﻠﻔﻜـﺮة، ﺣـﺎول ﻗـﺮاءة‬
                                      ‫اﻟﻔﻘﺮة ﺟﺪﻳﺪ ﻣﻊ ﺗﻄﺒﻴﻖ اﻷﻣﺜﻠﺔ اﻟﻤﺪرﺟﺔ.‬
‫- ﺣﺎول اﺑﺘﻜﺎر اﻣﺜﻠﺔ ﺟﺪﻳﺪة ﻣﻦ وﺣﻲ اﻓﻜﺎرك، وﻗـﻢ ﺑﺘﻄﺒﻴﻘﻬـﺎ، ﻟﺘﺘﻤـﺮس ﻋﻠـﻰ هـﺬا‬
                                                       ‫اﻷﺳﻠﻮب ﻣﻦ اﻟﺒﺮﻣﺠﺔ.‬


                                                             ‫ﻣﻘﺪﻣﺔ اﻟﻰ ‪OOP‬‬
‫اذا آﻨﺖ ﻋﻠﻰ دراﻳﺔ آﺎﻓﻴﺔ ﺑﻤﺼﻄﻠﺢ اﻟﺒﺮﻣﺠﺔ آﺎﺋﻨﻴﺔ اﻟﺘﻮﺟـﻪ ‪ OOP‬ﻓﺘﺴـﺘﻄﻴﻊ اﻻﻧﺘﻘـﺎل‬
‫اﻟﻰ ﻓﻘﺮة ﺑﻨﺎء اول ﻓﺌﺔ ﻣﺒﺴﻄﺔ، اﻣﺎ ان آﻨـﺖ ﺟﺪﻳـﺪا ﻋﻠـﻰ ‪ OOP‬ﻓﻴﻤﻜﻨﻨـﻲ ان اﻋـﺮف‬
‫ﻟﻚ اﻟﺒﺮﻣﺠﺔ آﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ ﻋﻠﻰ اﻧﻬﺎ ﺑﺮﻣﺠﺔ ﻣﻮﺟﻬﻪ ﻧﺤﻮ آﺎﺋﻨﺎت او اهﺪاف، ﻓﻜﻞ ﺷـﺊ‬
                                                ‫051‬


‫ﻓﻲ ﺑﺮﻧﺎﻣﺠﻚ ﻋﺒﺎرة ﻋﻦ آﺎﺋﻦ ‪ Object‬او ﺷﺊ ‪ Thing‬ﻟﻪ ﺑﻴﺎﻧﺎت واﻓﻌـﺎل ﺧﺎﺻـﺔ ﺑـﻪ أي‬
‫اﺷﺒﻪ ﺑﺎﻟﻌﺎﻟﻢ اﻟﺤﻘﻴﻘﻲ اﻟﺬي ﺗﺮاﻩ ﻳﻮﻣﻴﺎ، ﻓﺎﻻﻧﺴﺎن آﺎﺋﻦ ﻟـﻪ ﺻـﻔﺎت ﻣﻌﻴﻨـﺔ )ﺧﺼـﺎﺋﺺ‬
 ‫ـ‬                                    ‫ـ‬
‫‪ (Properties‬آﺎﻻﺳـﻢ، اﻟﻌﻤـﺮ، اﻟﻠـﻮن، اﻟﻄـﻮل، اﻟـﻮزن، .... اﻟـﺦ، وﻟـﻪ اﻓﻌـﺎل ﻳﻘـﻮم ﺑﻬـﺎ‬
‫)ﻃﺮق ‪ (Methods‬آﺎﻟﻤﺸﻲ، اﻟﻜﺘﺎﺑﺔ، اﻟﻀﺤﻚ، اﻟﺒﻜﺎء، اﻟﻨﻮم، .... اﻟﺦ، آﻤﺎ ان اﻻﻧﺴﺎن‬
‫ﺗﺤﺪث ﻋﻠﻴﻪ وﻗﺎﺋﻊ )اﺣﺪاث ‪ (Events‬ﺗﺆﺛﺮ ﻓﻴﻪ وﻳﻨﺘﺞ ﻋﻨﻬﺎ ردود ﻓﻌﻞ آﺎﺳـﺘﻘﺒﺎل رﺳـﺎﻟﺔ‬
‫ﻣﻔﺮﺣﺔ او ﻣﺤﺰﻧﺔ، اﻟﺘﻌﺮض ﻟﺠﻠﻄﺔ ﻓﻲ اﻟﻤﺦ، وﺻﻮل ﻟﻜﻤﺔ ﺧﻄﺎﻓﻴﺔ ﻓﻲ اﻟﻔـﻚ اﻻﻳﻤـﻦ،‬
                                                  ‫ﺻﻔﻌﺔ ﻗﻮﻳﺔ ﻓﻲ اﻟﺨﺪ اﻻﻳﺴﺮ، .... اﻟﺦ.‬
‫آﺬﻟﻚ اﻟﺤﺎل ﻣـﻊ آﺎﺋﻨـﺎت ‪ ،Visual Basic‬ﻓﻬـﻲ ﺗﺤﺘـﻮي ﻋﻠـﻰ ﺧﺼـﺎﺋﺺ ﺗﺤـﻮي ﺑﻴﺎﻧـﺎت‬
‫ﺧﺎﺻﺔ ﺑﻬﺎ ﻣﺜﻞ: ‪ .... BackColor ،Height ،Left‬اﻟﺦ، وﻃـﺮق ﻟﺘﻔﻌـﻞ اﻓﻌـﺎل ﺧﺎﺻـﺔ ﺑﻬـﺎ‬
‫ﻣﺜﻞ: ‪ .... ZOrder ،Refresh ،Move‬اﻟﺦ، واﺣﺪاث ﺗﻘﻊ ﻋﻠﻴﻬﺎ آــ ‪،MouseMove ،Click‬‬
                                         ‫‪ .... ،KeyPress‬اﻟﺦ ﺗﻨﺘﺞ ﻋﻨﻬﺎ ردود ﻓﻌﻞ ﺧﺎﺻﺔ.‬

                                                                      ‫ﻟﻤﺎذا ‪OOP‬؟‬
        ‫ﺑﺼﺮاﺣﺔ اﻟﻔﻮاﺋﺪ اﻟﺘﻲ ﺗﺠﻨﻴﻬﺎ ﻣﻦ ‪ OOP‬آﺜﻴﺮة ﺟﺪا وﻟﻜﻨﻲ ﺳﺎﺧﺘﺼﺮ ﺛﻼﺛﺔ ﻣﻨﻬﺎ:‬

‫ﻋﻨﺪﻣﺎ ﺗﻜﺒﺮ ﺣﺠﻢ اﻟﺒﺮاﻣﺞ ﺗﺰداد ﻋﻤﻠﻴـﺔ ادارﺗﻬـﺎ ﺗﻌﻘﻴـﺪا، ﻟﻜـﻦ ﻣـﻊ ‪ OOP‬ﻓﺎﻟﺒﺮﻧـﺎﻣﺞ‬          ‫-‬
‫ﻳﺘﻜﻮن ﻣﻦ ﻣﺠﻤﻮﻋﺔ آﺎﺋﻨﺎت ﺑﺤﻴﺚ اﻧﻪ ﻟﻮ ﺣﺪﺛﺖ ﻣﺸـﻜﻠﺔ ﻓـﻲ اﺣـﺪهﺎ ﻓﻜـﻞ ﻣـﺎهﻮ‬
‫ﻣﻄﻠﻮب هﻮ ﺗﻌـﺪﻳﻞ ذﻟـﻚ اﻟﻜـﺎﺋﻦ دون ان ﺗﺘـﺄﺛﺮ اﻟﻜﺎﺋﻨـﺎت اﻻﺧـﺮى، وﺣﺘـﻰ ﻟـﻮ اردت‬
‫ﺗﻄﻮﻳﺮ اﺣﺪ اﻟﻜﺎﺋﻨﺎت ﻓﻠﺴﺖ ﻣﻀﻄﺮا اﻟﻰ ﺗﻨﻘﻴﺢ ﺁﻻف اﻻﺳﻄﺮ ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ، وآﻞ ﻣﺎ‬
                 ‫ﻳﺘﻮﺟﺐ ﻋﻠﻴﻚ اﻟﻘﻴﺎم ﺑﻪ هﻮ اﻻﻧﺘﻘﺎل اﻟﻰ آﻮد اﻟﻔﺌﺔ وﺗﻄﻮﻳﺮﻩ ﻓﻘﻂ.‬

‫ﺗﺼﻤﻴﻢ اﻟﺒﺮاﻣﺞ واﻟﺘﺨﻄﻴﻂ ﻟﺒﻨﻴﺘﻬﺎ اﺻـﺒﺤﺖ اﺳـﻬﻞ ﻣـﻦ اﻟﺒﺮﻣﺠـﺔ اﻻﺟﺮاﺋﻴـﺔ واﻗـﺮب‬              ‫-‬
‫اﻟﻰ اﻟﻌﺎﻟﻢ اﻟﺤﻘﻴﻘﻲ، ﻓﻌﻨﺪﻣﺎ ﺗﺨﻄﻂ ﻟﺒﺮﻧﺎﻣﺞ ﺟﺪﻳـﺪ ﻓﻨﻈﺮﺗـﻚ ﺳـﺘﻜﻮن ﺑﻌﻴـﺪة ﻋـﻦ‬
‫اﻻآﻮاد وﻗﺮﻳﺒﺔ اﻟـﻰ اﻟﺘﺼـﻤﻴﻢ ﺑﺤﻴـﺚ ﺗﻨﺠـﺰ ﻣﻬﺎﻣـﻚ ﺑﺴـﺮﻋﺔ اآﺒـﺮ وﺳـﻬﻮﻟﺔ اآﺜـﺮ.‬
‫ﻓﻌﻨﺪﻣﺎ ﺗﺼﻤﻢ ﻓﺌﺔ ﺟﺪﻳﺪة، ﻓﻠﻦ ﻳﺸﻐﻠﻚ أي آﻮد او ﻣﺘﻐﻴﺮ ﺧﺎرج هﺬﻩ اﻟﻔﺌﺔ ﻗﺪ ﻳـﺆﺛﺮ‬
‫ﻋﻠﻰ ﺳﻠﻮك ﺗﻨﻔﻴﺬ اﻻآﻮاد، وﺳﻴﻜﻮن آﻞ ﺗﺮآﻴـﺰك ﻋﻠـﻰ هـﺬﻩ اﻟﻔﺌـﺔ وآﺄﻧﻬـﺎ اﻟﺠـﺰء‬
‫اﻟﻮﺣﻴــﺪ اﻟﻤﻮﺟــﻮد ﻓــﻲ اﻟﺒﺮﻧــﺎﻣﺞ، ﻣﻤــﺎ ﻳﻘﻠــﻞ ﻧﺴــﺒﺔ اﻟﺸــﻮاﺋﺐ ‪ Bugs‬وﻋــﺪم ﺗــﺄﺛﺮ‬
                                                        ‫ﻣﺘﻐﻴﺮات وﺑﻴﺎﻧﺎت ﺑﺮﻧﺎﻣﺠﻚ.‬

‫‪ OOP‬ﺳﺘﺠﻌﻞ ﺣﻴﺎﺗﻚ اﺳﻬﻞ، ﻓﻠﻮ ﺗﺨﻴﻠـﺖ ‪ Visual Basic‬دون آﺎﺋﻨـﺎت واردت ﺗﻐﻴﻴـﺮ‬                 ‫-‬
                                          ‫اﺳﻢ اﻟﻨﺎﻓﺬة، ﻓﻘﺪ ﺗﻜﺘﺐ ﺷﻴﺌﺎ ﻣﺜﻞ:‬
                                               ‫151‬


‫‪Dim hWND As Long‬‬
‫)”1‪hWND = FindWindow (“Form‬‬
‫)”‪ChangeCaption ( hWND, “Main Menu‬‬
‫ﻟﻜﻦ ﻣﻊ ‪ OOP‬ﻓﺎﻧﻚ ﺗﺘﺤﺪث ﻋﻦ آﺎﺋﻦ اﺳﻤﻪ 1‪ Form‬وﺗﻘﻮم ﺑﺘﻐﻴﻴﺮ ﺧﺎﺻـﻴﺘﻪ ‪Caption‬‬
                                     ‫اﻟﻰ اﻻﺳﻢ اﻟﺬي ﺗﺮﻳﺪﻩ ﺑﺴﻬﻮﻟﺔ ﺷﺪﻳﺪة.‬

                                                                   ‫ﺳﻤﺎت ‪OOP‬‬
    ‫ـ‬      ‫ـ‬                  ‫ـ‬           ‫ـ‬
‫ﻣـﻦ اﻟﻀـﺮوري ان اوﺿـﺢ اﻟﻔـﺮق ﺑـﻴﻦ اﻟﻔﺌـﺔ ‪ Class‬واﻟﻜـﺎﺋﻦ ‪ ،Object‬ﻓﺎﻟﻔﺌـﺔ –ﺑﺸـﻜﻞ‬
                                                ‫ـ‬   ‫ـ‬      ‫ـ‬             ‫ـ‬       ‫ـ‬
‫ﻣﺒﺴﻂ- هﻲ ﻣﺠﺮد وﺻﻒ ﻟﺨﺼﺎﺋﺺ، ﻃـﺮق واﺣـﺪاث اﻟﻜـﺎﺋﻦ، ﺑﻴﻨﻤـﺎ اﻟﻜـﺎﺋﻦ هـﻮ وﺣـﺪة‬
‫ﺗﺤﺘﻮي ﻋﻠﻰ ﺑﻴﺎﻧﺎت واآﻮاد ﻣﻌﺮﻓﺔ ﻓﻲ اﻟﻔﺌﺔ. اﻋﻮد ﻟﻠﻤﺜﺎل اﻟﺴﺎﺑﻖ، ﻓﺎﻻﻧﺴﺎن هﻮ ﻓﺌـﺔ‬
‫ﺧﻠﻘﻬﺎ اﷲ ﻋﺰ وﺟﻞ واﺻﻔﺔ ﻟﺨﺼﺎﺋﺺ، ﻃﺮق واﺣﺪاث آﺎﺋﻨﺎت ﻣﺸﺘﻘﺔ ﻣﻨﻬﺎ، ﻓﺄﻧﺎ –واﻋﻮذ‬
‫ﺑﺎﷲ ﻣﻦ آﻠﻤﺔ اﻧﺎ- آﺎﺋﻦ ﻟﺪي ﺧﺼﺎﺋﺺ ﻣﻦ ﻓﺌﺔ اﻻﻧﺴﺎن آﺎﻻﺳﻢ ﺗﺮآﻲ، اﻟﻌﻤـﺮ 99 ....‬
‫اﻟﺦ، واﻧﺖ اﻳﻀﺎ آﺎﺋﻦ ﻟﺪﻳﻚ ﺧﺼﺎﺋﺺ ﻣﻦ ﻧﻔﺲ اﻟﻔﺌﺔ "اﻻﻧﺴـﺎن" آﺎﺳـﻤﻚ س، ﻋﻤـﺮك‬
‫ص .... اﻟــﺦ. آــﺬﻟﻚ اﻟﺤــﺎل ﻣــﻊ ‪ ،Visual Basic‬ﻓــﺎدوات اﻟــﻨﺺ 1‪ Text‬و 2‪ Text‬هــﻲ‬
‫آﺎﺋﻨﺎت ﻣﻦ اﻟﻔﺌـﺔ ‪ ،TextBox‬وادوات اﻟﻌﻨـﻮان 1‪ Label2 ،Label‬و 3‪ Labe‬هـﻲ آﺎﺋﻨـﺎت‬
                                                                ‫ﻣﻦ اﻟﻔﺌﺔ ‪.Label‬‬
                             ‫ﺑﻮدي ان اﻋﺮض ﻋﻠﻴﻚ ﺑﺎﺧﺘﺼﺎر اﻟﺴﻤﺎت اﻟﺜﻼث ﻟـ ‪:OOP‬‬

                                                                           ‫اﻟﺘﻐﻠﻴﻒ:‬
‫ﻳﻘﺼﺪ ﺑﺎﻟﺘﻐﻠﻴﻒ ‪ Encapsulation‬ﻓﻲ ﻟﻐـﺎت ‪ OOP‬ﺑﻮﺿـﻊ ﺟﻤﻴـﻊ اﻻﺷـﻴﺎء ﻣﻌـﺎ ‪Putting‬‬
‫‪ ،everything together‬ﺑﺤﻴﺚ ﺗﺤﻘﻖ اﺳﺘﻘﻼﻟﻴﺔ اﻟﻜﺎﺋﻦ اﻟﻤﻄﻠﻘﺔ ﺑﺒﻴﺎﻧﺎﺗـﻪ اﻟﺨﺎﺻـﺔ ﺑـﻪ‬
‫وﺣﺘﻰ اآﻮادﻩ، ﻣﻦ اﻟﻤﺰاﻳﺎ اﻟﺘﻲ ﻳﻘﺪﻣﻬﺎ ﻟﻚ اﻟﺘﻐﻠﻴﻒ هﻮ اﻣﻜﺎﻧﻴﺔ ﺗﻄـﻮﻳﺮ اﻟﺒﻨﻴـﺔ اﻟﺘﺤﺘﻴـﺔ‬
‫ﻟﻠﻜﺎﺋﻦ ﺑﺪون ان ﻳﺘﺄﺛﺮ ﺗﺮآﻴﺐ ﺑﺮﻧﺎﻣﺠﻚ ودون اﻟﺤﺎﺟﺔ اﻟﻰ ﺗﻌﺪﻳﻞ ﺳﻄﺮ واﺣﺪ ﻣـﻦ اآـﻮاد‬
‫اﻟﺒﺮﻧﺎﻣﺞ، ﻣﺜﻼ ﻟﻮ ﻗﻤﺖ ﺑﺘﺼﻤﻴﻢ ﻓﺌﺔ ﻟﻠﺒﺤﺚ ﻋﻦ اﻟﻤﻠﻔﺎت واﻋﺘﻤﺪت ﻋﻠﻴﻪ ﺑﺪرﺟﺔ آﺒﻴـﺮة‬
‫ﻓﻲ ﺑﺮﻧﺎﻣﺠﻚ، وﺑﻌﺪ ﻓﺘﺮة ﻣـﻦ اﻻﺧﺘﺒـﺎرات واﻟﺘﺠـﺎرب اﻟﻘﻮﻳـﺔ ﻻﺣﻈـﺖ ﺑـﻂء ﻓـﻲ ﻋﻤﻠﻴـﺔ‬
‫اﻟﺘﻨﻔﻴﺬ، ﻓﻜﻞ ﻣﺎ ﺳﺘﻔﻌﻠﻪ هـﻮ ﺗﻌـﺪﻳﻞ اﻟﺒﻨﻴـﺔ اﻟﺘﺤﺘﻴـﺔ ﻟﻠﻔﺌـﺔ اﻟﺨﺎﺻـﺔ ﺑﺎﻟﺒﺤـﺚ وﺗﻄـﻮﻳﺮ‬
‫ﺧﻮارزﻣﻴــﺎت اآﻮادهــﺎ دون ﺗﻐﻴﻴــﺮ ﺳــﻄﺮ واﺣــﺪ ﻣــﻦ ﺳــﻄﻮر اﻟﺒﺮﻧــﺎﻣﺞ اﻻﺧــﺮى واﻟﺘــﻲ‬
                                                       ‫ﺗﺴﺘﻌﻤﻞ هﺬﻩ اﻟﻔﺌﺔ ﺑﺎﻟﺘﺤﺪﻳﺪ.‬
‫آﻠﻤﺎ زادت اﺳﺘﻘﻼﻟﻴﺔ اﻟﻔﺌـﺔ، آﻠﻤـﺎ زادت آﻔـﺎءة اﻋـﺎدة اﺳـﺘﺨﺪاﻣﻬﺎ ﻓـﻲ ﺑﺮﻧـﺎﻣﺞ ﺁﺧـﺮ‬
‫وﺗﻄﺒﻴﻖ اﺳﻠﻮب اﻋـﺎدة اﺳـﺘﺨﺪام اﻻآـﻮاد ‪ .Code Reusability‬ﻣﺒـﺪأ اﻋـﺎدة اﺳـﺘﺨﺪام‬
‫اﻻآﻮاد ﻣﻦ اﺣﺪ اﻟﻤﺒﺎدئ اﻟﻀﺮورﻳﺔ اﻟﺘﻲ ﻳﺘﻮﺟﺐ ﻋﻠﻴﻚ ﻣﺤﺎوﻟﺔ واﻟﺘﻌـﻮد ﻋﻠـﻰ ﺗﻄﺒﻴﻘﻬـﺎ‬
‫داﺋﻤﺎ ﻓﻲ ﺑﺮاﻣﺠﻚ وﻣﺸﺎرﻳﻌﻚ اﻟﻴﻮﻣﻴﺔ، ﺑﺤﻴﺚ ﺗﺘﻤﻜﻦ ﻣﻦ اﻻﺳﺘﻔﺎدة ﻣـﻦ اﻟﻔﺌـﺔ اﻟﺘـﻲ‬
‫ﺻﻤﻤﺘﻬﺎ ﻓﻲ اآﺜﺮ ﻣﻦ ﻣﺸﺮوع واآﺜـﺮ ﻣـﻦ ﺑﺮﻧـﺎﻣﺞ. وﺣﺘـﻰ ﺗﻨﺸـﺊ ﻓﺌـﺔ ﻗﺎﺑﻠـﺔ ﻻﻋـﺎدة‬
‫اﻻﺳﺘﺨﺪام، ﺣﺎول داﺋﻤﺎ وﻗﺒﻞ ان ﺗﺒﺪأ ﺑﻜﺘﺎﺑﺔ ﺳﻄﺮ واﺣـﺪ ﻣـﻦ اﻟﻔﺌـﺔ ﺑﺎﺧـﺬ اﺣﺘﻴﺎﻃﺎﺗـﻚ‬
                                             ‫251‬


‫ﻟﻠﻤﺴﺘﻘﺒﻞ واﺳﺄل ﻧﻔﺴﻚ اﺳﺌﻠﺔ ﺷﺒﻴﻬﻪ ﺑـ: آﻴﻒ ﻳﻤﻜﻨﻨﻲ اﻻﺳﺘﻔﺎدة ﻣﻦ هﺬﻩ اﻟﻔﺌـﺔ‬
‫ﻓﻲ ﺑﺮﻧﺎﻣﺞ ﺁﺧﺮ؟ آﻴﻒ اﺳﻤﻲ واﺣﺪد اﻟﺨﺼﺎﺋﺺ، اﻟﻄﺮق واﻻﺣﺪاث ﺑﺤﻴـﺚ ﺗﻜـﻮن ﻗﺎﺑﻠـﺔ‬
‫ﻟﻠﻌﻤﻞ ﻣﻊ اآﺜﺮ ﻣﻦ ﺑﺮﻧﺎﻣﺞ وﻗﺎﺑﻠﺔ ﻟﻠﺘﻄﻮﻳﺮ اﻳﻀﺎ ؟ آﻴﻒ اﺟﻌﻞ هﺬﻩ اﻟﻔﺌﺔ ﻣﺴـﺘﻘﻠﺔ ﻗـﺪر‬
‫اﻟﻤﺴﺘﻄﺎع ﻋﻦ أي اآﻮاد او آﺎﺋﻨﺎت اﺧﺮى ﻓـﻲ اﻟﺒﺮﻧـﺎﻣﺞ ﺑﺤﻴـﺚ ﻳﻤﻜﻨﻨـﻲ اﺳـﺘﺨﺪاﻣﻬﺎ‬
‫ﻓﻲ ﺑﺮﻧﺎﻣﺞ ﺁﺧﺮ؟ ....اﻟﺦ ﻣﻦ اﻻﺳﺌﻠﺔ واﻻﻋﺘﺒﺎرات اﻟﺘﻲ ﻻﺑﺪ ﻣـﻦ وﺿـﻌﻬﺎ ﻓـﻲ اﻻﻋﺘﺒـﺎر‬
                                ‫ﻗﺒﻞ ﺑﻨﺎء اﻟﻔﺌﺔ وﻋﻨﺪ آﺘﺎﺑﺔ آﻞ اﺟﺮاء ﻣﻦ اﺟﺮاءاﺗﻬﺎ.‬

                                                                ‫ﺗﻌﺪد اﻟﻮاﺟﻬﺎت:‬
‫ﺑﺒﺎﺳﻄﺔ ﻣﺒﺪأ ﺗﻌﺪد اﻟﻮاﺟﻬﺎت ‪ Polymorphism‬هﻮ ﻗﺪرة اﻟﻔﺌﺔ ﻋﻠﻰ اﺣﺘﻮاﺋﻬﺎ اآﺜـﺮ ﻣـﻦ‬
‫واﺟﻬﺔ ﺑﺤﻴﺚ ﺗﻤﻜﻨﻚ ﻣﻦ ﺗﻮﺣﻴﺪ ﻋـﺪة ﻓﺌـﺎت ﻣﺨﺘﻠﻔـﺔ ﺑﺎﺳـﻤﺎء اﻋﻀـﺎء ﻣﺘﺸـﺎﺑﻬﻪ، ﻓﻠـﻮ‬
                                                                ‫ﻼ‬
‫اﻣﻌﻨﺖ اﻟﻨﻈﺮ ﻗﻠﻴ ً ﻓﻲ ادوات ‪ Visual Basic‬ﺳﺘﺠﺪ اﻧﻬﺎ ﻣﺨﺘﻠﻔﺔ اﻟﻤﻬﺎم واﻻﻧﺠـﺎزات اﻻ‬
‫اﻧﻬــﺎ ﺗﺤﺘــﻮي ﻋﻠــﻰ ﺧﺼــﺎﺋﺺ، ﻃــﺮق واﺣــﺪاث ﻣﺸــﺘﺮآﺔ آـــ ‪Move ،Left‬و ‪ Click‬ﻣﻤــﺎ‬
‫ﻳﺴﻬﻞ ﻋﻠﻴﻚ آﻤﺒﺮﻣﺞ ﺣﻔﻈﻬﺎ وﺗﻮﺣﻴﺪ اﻻﺟﺮاءات اﻟﺘﻲ ﺗﺴﺘﺨﺪم هﺬﻩ اﻻﻋﻀﺎء. اﻟﻔﺼـﻞ‬
                                       ‫اﻟﻘﺎدم ﻳﻨﺎﻗﺶ ﻣﺒﺪأ ﺗﻌﺪد اﻟﻮاﺟﻬﺎت ﺑﺎﻟﺘﻔﺼﻴﻞ.‬

                                                                        ‫اﻟﻮراﺛﺔ:‬
‫اﻟﻮراﺛﺔ ‪ Inheritance‬هﻲ ﻗﺪرة ﻓﺌﺔ ﻋﻠﻰ اﺷﺘﻘﺎق اﻋﻀﺎء ﻣﻦ ﻓﺌﺔ ام ﺑﺤﻴـﺚ ﺗﺰﻳـﺪ ﻣـﻦ‬
‫ﻗﻮة اﻟﻔﺌﺔ اﻟﻮارﺛﺔ وﺗﻀﻴﻒ اﻋﻀﺎء ﺟﺪﻳـﺪة ﻟﻠﻔﺌـﺔ اﻻم، ﻓﻠـﻮ آـﺎن ﻟـﺪﻳﻚ ﻓﺌـﺔ ﻗﻮﻳـﺔ واردت‬
‫اﺿﺎﻓﺔ ﻃﺮﻳﻘﺔ او ﺧﺎﺻﻴﺔ ﻟﻬﺎ، ﻓـﻼ ﻳﻮﺟـﺪ داﻋـﻲ ﻻﻋـﺎدة ﺑﻨـﺎء اﻟﻔﺌـﺔ ﻣـﻦ ﺟﺪﻳـﺪ واﺿـﺎﻓﺔ‬
‫اﻟﺨﺎﺻﻴﺔ او اﻟﻄﺮﻳﻘﺔ اﻟﻤﻄﻠﻮﺑﺔ، ﻓﻜـﻞ ﻣـﺎ ﺳـﺘﻘﻮم ﺑـﻪ هـﻲ ﻋﻤﻠﻴـﺔ اﻧﺸـﺎء ﻓﺌـﺔ ﺧﺎﻟﻴـﺔ‬
‫ﺗﻀﻴﻒ اﻟﻴﻬﺎ اﻟﺨﺎﺻﻴﺔ او اﻟﻄﺮﻳﻘﺔ اﻟﺘﻲ ﺗﺮﻳﺪهﺎ وﻣﻦ ﺛﻢ ﺗﺸـﺘﻘﻬﺎ ﻣـﻦ اﻟﻔﺌـﺔ اﻟﺘـﻲ ﺗﺮﻳـﺪ‬
‫ﺗﻄﻮﻳﺮهﺎ واﺿﺎﻓﺔ اﻟﺨﺎﺻﻴﺔ او اﻟﻄﺮﻳﻘﺔ ﻟﻬﺎ. اﻟﻔﺼﻞ اﻟﻘﺎدم ﻳﻨﺎﻗﺶ ﻣﺒﺪأ اﻟﻮراﺛﺔ ﺑﺎﻟﺘﻔﺼﻴﻞ.‬

                                                     ‫ﺑﻨﺎء اول ﻓﺌﺔ ﻣﺒﺴﻄﺔ‬
‫واﻻن ﺷــﻐﻞ ‪ Visual Basic‬آــﻲ ﻧﺒــﺪأ ﺑﺘﺼــﻤﻴﻢ اول ﻓﺌــﺔ ﺗﻤﺜــﻞ ﺷــﺨﺺ ﺳﻨﺴــﻤﻴﻬﺎ‬
‫‪ .CPerson‬اﺧﺘﺮ اﻻﻣﺮ ‪ Add Class Module‬ﻣـﻦ ﻗﺎﺋﻤـﺔ ‪ ،Project‬وﻣـﻦ ﺻـﻨﺪوق اﻟﺤـﻮار‬
‫اﻟﺬي –ﻗﺪ- ﻳﻈﻬﺮ اﻣﺎﻣﻚ، اﺧﺘﺮ اﻟﺮﻣﺰ ‪ Class Module‬واﻧﻘﺮ ﻋﻠﻰ اﻟﺰر ‪ Open‬ﻟﺘﻈﻬـﺮ ﻟـﻚ‬
‫ﻧﺎﻓﺬة اآﻮاد ﺗﻌﺮﻳـﻒ اﻟﻔﺌـﺔ، اﺿـﻐﻂ ﻋﻠـﻰ اﻟﻤﻔﺘـﺎح ]4‪ [F‬ﻟﻌـﺮض ﻧﺎﻓـﺬة ﺧﺼـﺎﺋﺺ اﻟﻔﺌـﺔ،‬
        ‫وﻋﺪل ﺧﺎﺻﻴﺔ اﻻﺳﻢ ﻣﻦ 1‪ Class‬اﻟﻰ ‪ ،CPerson‬واآﺘﺐ هﺬا اﻟﻜﻮد ﻓﻲ اﻟﻔﺌﺔ:‬

‫‪Public sName As String‬‬
‫‪Public dBirthDate As Date‬‬
                                                ‫351‬


‫وﺑﻬﺬا ﻧﻜﻮن ﻗﺪ اﻧﺠﺰﻧﺎ اول ﻓﺌﺔ ﺑﺎﻻﺳﻢ ‪ CPerson‬ﺗﺤﺘـﻮي ﻋﻠـﻰ اﻟﺨﺎﺻـﻴﺘﻴﻦ ‪ sName‬و‬
     ‫ـ‬     ‫ـ‬      ‫ـ‬         ‫ـ‬           ‫ـ‬          ‫ـ‬          ‫ـ‬
‫‪ .dBirthDate‬ﺗﺴـﺘﻄﻴﻊ اﺳـﺘﺨﺪام اﻟﻔﺌـﺔ ‪ CPerson‬ﻓ ـﻲ أي ﻣﻜـﺎن داﺧـﻞ ﻣﺸ ـﺮوﻋﻚ،‬
                 ‫اذهﺐ اﻟﻰ اﻟﺤﺪث ‪ Click‬اﻟﺘﺎﺑﻊ ﻟﻨﺎﻓﺬة اﻟﻨﻤﻮذج واآﺘﺐ هﺬا اﻟﻜﻮد:‬

‫)(‪Private Sub Form_Click‬‬
   ‫‪Dim Turki As New cPerson‬‬
   ‫‪Dim Khaled As New cPerson‬‬

  ‫"ﺗﺮآﻲ اﻟﻌﺴﻴﺮي" = ‪Turki.sName‬‬
  ‫#0091/1/1# = ‪Turki.dBirthDate‬‬
  ‫"ﺧﺎﻟﺪ اﻻﺑﺮاهﻴﻢ" = ‪Khaled.sName‬‬
  ‫#9791/1/1# = ‪Khaled.dBirthDate‬‬
  ‫‪Print Turki.sName, Turki.dBirthDate‬‬
  ‫‪Print Khaled.sName, Khaled.dBirthDate‬‬
‫‪End Sub‬‬

‫ﻗﻤﻨﺎ -ﻓﻲ اﻟﻜﻮد اﻟﺴﺎﺑﻖ- ﺑﺎﻧﺸﺎء آﺎﺋﻨﻴﻦ ‪ Turki‬و ‪ Khaled‬ﻣـﻦ اﻟﻔﺌـﺔ اﻟﺘـﻲ ﺻـﻤﻤﻨﺎهﺎ‬
  ‫ـ‬
‫ﻟﻠﺘـﻮ ‪ ،CPerson‬وﻣـﻦ ﺛـﻢ ﻗﻤﻨـﺎ ﺑﺘﻌﻴـﻴﻦ ﻗـﻴﻢ ﻟﻠﺨﺎﺻـﻴﺘﻴﻦ ‪ sName‬و ‪ dBirthDate‬ﻟﻜـﻞ‬
             ‫ـ‬      ‫ـ‬           ‫ـ‬        ‫ـ ـ‬
‫آـﺎﺋﻦ ﻋﻠ ـﻰ ﺣ ـﺪة، وﺧﺘﻤﻨـﺎ اﻟﻜ ـﻮد ﺑﻄﺒﺎﻋ ـﺔ ﻗـﻴﻢ اﻟﺨﺼ ـﺎﺋﺺ اﻟﺘﺎﺑﻌ ـﺔ ﻟﻠﻜ ـﺎﺋﻨﻴﻦ ‪ Turki‬و‬
                                                       ‫ـ‬      ‫ـ‬         ‫ـ‬    ‫ـ‬       ‫ـ‬
                                                                               ‫‪.Khaled‬‬
‫ﺻﺤﻴﺢ ان اﻟﻔﺌﺔ اﻟﺴﺎﺑﻘﺔ ﻟﻦ ﺗﻄﺒﻘﻬﺎ ﻓﻲ ﺣﻴﺎﺗﻚ اﻟﺒﺮﻣﺠﻴﺔ –ﺑﺸﻜﻞ ﺟﺎد- ﻟﻄﺒﺎﻋـﺔ ﻗـﻴﻢ‬
‫ﻣﺘﻐﻴﺮات، اﻻ ان اﻟﻐﺮض اﻻﺳﺎﺳﻲ هﻮ ﻣﺠﺮد ﺗﻮﺿﻴﺢ ﻓﻜﺮة اﻟﻔﺌﺎت وﻃﺮﻳﻘﺔ اﺳﺘﺨﺪاﻣﻬﺎ.‬


                                                                                ‫ﺑﻨﺎء اﻟﻔﺌﺎت‬
‫واﻻن ﺑﻌﺪ ان ﻋﺮﻓﺘﻚ ﻋﻠﻰ اﻟﻔﻜﺮة اﻻﺳﺎﺳﻴﺔ ﻣﻦ اﻟﻔﺌﺎت ‪ Classes‬ﺳﻨﺒﺪأ ﺑﺎﻟﺘﻮﻏﻞ ﻓـﻲ‬
                  ‫ﺗﻔﺎﺻﻴﻞ ﺑﻨﺎء ﺧﺼﺎﺋﺼﻬﺎ، ﻃﺮﻗﻬﺎ واﺣﺪاﺛﻬﺎ ﺣﺘﻰ ﺗﺰﻳﺪ ﻣﻦ ﻗﻮة اﻟﻔﺌﺔ.‬

                                                                  ‫ﺑﻨﺎء اﻟﺨﺼﺎﺋﺺ‬
‫اذا ﻋﺪﻧﺎ اﻟﻰ ﻣﺜﺎل اﻟﻔﺌﺔ ‪ CPerson‬اﻟﺴﺎﺑﻖ، ﻓﺴـﻨﻼﺣﻆ ان اﻟﻤﺒـﺮﻣﺞ ﻳﺴـﺘﻄﻴﻊ اﺳـﻨﺎد‬
‫أي ﻗﻴﻤﺔ ﻟﻠﺨﺎﺻـﻴﺔ ‪ ،dBirthDate‬وﻗـﺪ ﻳﻌﻄـﻲ ﻓﺮﺻـﺔ ﻟﻠﻤﺴـﺘﺨﺪم ﺑﺎدﺧـﺎل اﻟﻌﻤـﺮ ﻣـﻦ‬
                                                                 ‫ﺧﺎﻧﺔ ﻧﺺ:‬

‫) ‪Turki.iAge = CDate ( Text1.Text‬‬
                                              ‫451‬



‫اﻟﻤﺸﻜﻠﺔ ﻓﻲ اﻟﻜـﻮد اﻟﺴـﺎﺑﻖ، ان اﻟﻤﺴـﺘﺨﺪم ﺑﺎﻣﻜﺎﻧـﻪ ادﺧـﺎل أي ﻋـﺪد ﻳﻤﺜـﻞ ﺗـﺎرﻳﺦ‬
‫ﻣﻴﻼد اﻟﺸﺨﺺ وﻗﺪ ﻳﻜﻮن ﺗﺎرﻳﺦ ﻟﻢ ﻳﺤﻞ ﺑﻌﺪ، ﻟﺬﻟﻚ ﻋﻠﻴﻚ اﻟﺘﺤﻘـﻖ ﻣـﻦ ﺗـﺎرﻳﺦ اﻟﻤـﻴﻼد‬
               ‫ﻓﻲ آﻞ ﻣﺮة ﺗﻤﻜﻦ اﻟﻤﺴﺘﺨﺪم ﻣﻦ ادﺧﺎل ﻗﻴﻤﺔ ﻟﻠﺨﺎﺻﻴﺔ ‪:dBirthDate‬‬

‫‪If CDate( Text1.Text ) > Date Then‬‬
       ‫”ﺧﻄﺄ ﻓﻲ اﻟﻘﻴﻤﺔ“ ‪MsgBox‬‬
‫‪Else‬‬
       ‫)‪Turki. dBirthDate= CDate(Text1.Text‬‬
‫‪End If‬‬

‫ﻳﻌﻴﺐ اﻟﻜﻮد اﻟﺴﺎﺑﻖ اﻧﻪ ﻳﻠﺰﻣﻚ ﺑﻌﻤﻠﻴﺔ اﻟﺘﺤﻘﻖ ﻣﻦ اﻟﻘﻴﻤﺔ ﻓﻲ آـﻞ ﻣـﺮة ﺗﺮﻳـﺪ اﺳـﻨﺎد‬
‫ﻗﻴﻤﺔ ﻟﻠﺨﺎﺻﻴﺔ ‪ ،dBirthDate‬واﻟﺤﻞ هﻮ ﺑﺎﺳﺘﺨﺪام ﻧﻮع ﺧﺎص ﻣـﻦ اﻻﺟـﺮاءات ﻳﺴـﻤﻰ‬
                   ‫اﻟﺨﺼﺎﺋﺺ واﻟﺘﻲ ﺗﻤﺜﻞ ﺧﺼﺎﺋﺺ اﻟﻜﺎﺋﻦ ﻟﺘﺤﻤﻴﻪ ﻣﻦ اﻟﻘﻴﻢ اﻟﺨﺎﻃﺌﺔ:‬

‫‪Private m_dBirthDate As Date‬‬

‫‪Public Property Get dBirthDate () As Date‬‬
  ‫‪dBirthDate= m_dBirthDate‬‬
‫‪End Property‬‬

‫)‪Public Property Let dBirthDate (ByVal dNewValue As Date‬‬
  ‫‪If dNewValue > Date Then‬‬
      ‫”ﺧﻄﺄ ﻓﻲ اﻟﻘﻴﻤﺔ“ ‪MsgBox‬‬
      ‫‪m_dBirthDate = Date‬‬
  ‫‪Else‬‬
      ‫‪m_dBirthDate= dNewValue‬‬
  ‫‪End If‬‬
‫‪End Property‬‬

 ‫ﻓﻲ اﻟﺤﻘﻴﻘﺔ، اﻇﻬﺎر رﺳﺎﻟﺔ ‪ MsgBox‬ﻣﻦ داﺧﻞ اﻟﻔﺌﺔ –آﻤﺎ ﻓﻲ اﻟﻜﻮد‬         ‫ﻣﻼﺣﻈﺔ:‬
 ‫اﻟﺴﺎﺑﻖ- ﻳﻌﺘﺒﺮ اﺳـﻠﻮب ﻏﻴـﺮ اﺣﺘﺮاﻓـﻲ وﺗﺼـﻤﻴﻢ ﺳـﻲء ﺟـﺪا ﻟﻠﻔﺌـﺎت‬
 ‫ﺧﺎﺻﺔ ﻋﻨﺪﻣﺎ ﺗﺰﻳـﺪ اﺣﺠﺎﻣﻬـﺎ، وﻳﻔﻀـﻞ ارﺳـﺎل رﺳـﺎﻟﺔ ﺧﻄـﺄ ﺑﺎﻟﻄﺮﻳﻘـﺔ‬
            ‫ـ‬           ‫ـ‬     ‫ـ‬                  ‫ـ‬    ‫ـ‬
 ‫‪ Err.Raise‬ﺑ ـﺪﻻ ﻣ ـﻦ ‪ .MsgBox‬اﻻ اﻧﻨ ـﻲ اﺳ ـﺘﺨﺪﻣﺖ اﻟﺪاﻟ ـﺔ ‪MsgBox‬‬
                                    ‫ﻓﻲ اﻟﻤﺜﺎل ﻟﺘﻘﺮﻳﺐ اﻟﻔﻜﺮة اﻟﻴﻚ.‬
                                             ‫551‬


‫ﺳﻴﻨﺎرﻳﻮ ﺗﻨﻔﻴﺬ اﻻﺟﺮاءات اﻟﺴـﺎﺑﻘﺔ ﺳـﻴﻜﻮن آﺎﻟﺘـﺎﻟﻲ: ﻓـﻲ آـﻞ ﻣـﺮة ﺗﻘـﻮم ﺑﺘﻌﻴـﻴﻦ او‬
‫اﺳﻨﺎد ﻗﻴﻤﺔ ﺟﺪﻳﺪة ﻟﻠﺨﺎﺻﻴﺔ ‪ ،dBirthDate‬ﺳﻴﺘﻢ اﺳـﺘﺪﻋﺎء اﻻﺟـﺮاء ‪Let dBirthDate‬‬
‫وارﺳﺎل اﻟﻘﻴﻤﺔ اﻟﺠﺪﻳﺪة اﻟﻰ اﻟﻤﺘﻐﻴﺮ ‪ ،dNewValue‬وﻓﻲ آﻞ ﻣﺮة ﺗﻘـﻮم ﺑﻘـﺮاءة ﻗﻴﻤـﺔ‬
‫اﻟﺨﺎﺻﻴﺔ ‪ ،dBirthDate‬ﺳﻴﺘﻢ اﺳﺘﺪﻋﺎء اﻻﺟـﺮاء ‪ Get dBirthDate‬واﻟـﺬي ﻳﻌـﻮد ﺑﻘﻴﻤـﺔ‬
‫اﻟﺨﺎﺻﻴﺔ. ﺑﺎﻣﻜﺎﻧﻚ اﻳﻀﺎ اﺿﺎﻓﺔ ﺧﺎﺻﻴﺔ ﺟﺪﻳﺪة ‪ iAge‬دون اﻟﺤﺎﺟﺔ ﻟﺘﻌﺮﻳـﻒ ﻣﺘﻐﻴـﺮ ﺧـﺎص‬
                                                                  ‫‪ Private‬ﻟﻬﺎ:‬

‫‪Public Property Get iAge() As Integer‬‬
  ‫)‪iAge = DateDiff("yyyy", m_dBirthDate, Date‬‬
‫‪End Property‬‬

‫ﺗﻼﺣﻆ اﻧﻨﻲ ﻟﻢ اﺳﺘﺨﺪم اﻻ اﺟﺮاء واﺣـﺪ وهـﻮ ‪ Get iAge‬وﺗﺠﺎهﻠـﺖ اﻻﺟـﺮاء ‪Let iAge‬‬
‫وذﻟﻚ ﻻﻧﻲ ارﻳﺪ ان اﺟﻌﻞ اﻟﺨﺎﺻﻴﺔ ‪ iAge‬ﻟﻠﻘﺮاءة ﻓﻘﻂ ‪ ،Read Only‬ﻓﻠﻮ ﺣﺎول اﻟﻤﺒـﺮﻣﺞ‬
   ‫ﺗﻌﻴﻴﻦ او آﺘﺎﺑﺔ ﻗﻴﻤﺔ ﺟﺪﻳﺪة ﻟﻠﺨﺎﺻﻴﺔ ﺳﺘﻈﻬﺮ رﺳﺎﻟﺔ ﺧﻄﺄ ‪:Read Only Property‬‬

‫‪Print Turki.iAge‬‬      ‫ﻣﻤﻜﻦ ﺟﺪا ‘‬
‫08 = ‪Turki.iAge‬‬       ‫رﺳﺎﻟﺔ ﺧﻄﺄ ‘‬

‫وﺑﺎﻣﻜﺎﻧﻚ ﺗﻄﺒﻴﻖ اﻟﻌﻜﺲ، أي اﺳﺘﺨﺪام اﻻﺟﺮاء ‪ Property Let‬دون اﻻﺟﺮاء ‪Property‬‬
                        ‫‪ Get‬ﻟﺘﺠﻌﻞ اﻟﺨﺎﺻﻴﺔ ﻟﻠﻜﺘﺎﺑﺔ ﻓﻘﻂ ‪:Write Only Property‬‬

‫‪Private m_sPassword As String‬‬

‫)‪Public Property Let sPassword ( sNewValue As String‬‬
  ‫‪m_sPassword = sNewValue‬‬
‫‪End Property‬‬

‫اﻟﻤﺰﻳﺪ اﻳﻀﺎ، ﻳﻤﻜﻨـﻚ اﻟﺘﻌﺎﻣـﻞ ﻣـﻊ اﺟـﺮاءات اﻟﺨﺼـﺎﺋﺺ آـﺎﺟﺮاءات ‪ Sub’s‬او ‪Functions‬‬
                                  ‫ﻋﺎدﻳﺔ ﻟﺘﻤﻜﻨﻬﺎ ﻣﻦ اﺳﺘﻘﺒﺎل ﻗﻴﻢ ‪:Parameters‬‬

‫‪Private m_sAddress (2) As String‬‬

‫‪Public Property Get sAddress( iIndex As Integer) As String‬‬
  ‫) ‪sAddress = m_sAddress ( iIndex‬‬
‫‪End Property‬‬
                                             ‫651‬


‫)‪Public Property Let sAddress(iIndex As Integer, sNewValue As String‬‬
  ‫‪m_sAddress ( iIndex ) = sNewValue‬‬
‫‪End Property‬‬

                              ‫وﺑﺎﻣﻜﺎﻧﻚ اﺳﺘﺪﻋﺎء اﻟﺨﺎﺻﻴﺔ ‪ sAddress‬ﺑﻬﺬﻩ اﻟﻄﺮﻳﻘﺔ:‬

‫”ﺣﻲ اﻟﻮهﻢ – ﺷﺎرع اﻟﺤﻘﻴﻘﺔ“ = )0( ‪Turki.sAddress‬‬
‫”وﻻﻳﺔ ﻓﻠﻮرﻳﺪا – ﺑﺎآﺴﺘﺎن“ = )1( ‪Turki.sAddress‬‬
‫”هﺎﺗﻒ ﻣﻨﺰل 999“ = )2( ‪Turki.sAddress‬‬

‫وﻋﻨﺪ اﻟﺤﺪﻳﺚ ﻋﻦ اﻟﺨﺼﺎﺋﺺ اﻟﺘﻲ ﺗﻤﻜﻨﻚ ﻣﻦ اﺳﻨﺎد ﻗﻴﻢ ﻟﻜﺎﺋﻨـﺎت، ﻓﻌﻠﻴـﻚ اﺳـﺘﺨﺪام‬
                           ‫اﻻﺟﺮاء ‪ Property Set‬ﻋﻮﺿﺎ ﻋﻦ اﻻﺟﺮاء ‪:Property Let‬‬

‫‪Private m_PersonParent As CPerson‬‬

‫‪Public Property Get PersonParent( ) As CPerson‬‬
  ‫‪Set PersonParent = m_PersonParent‬‬
‫‪End Property‬‬

‫) ‪Public Property Set PersonParent( ByVal objNewValue As CPerson‬‬
  ‫‪Set m_PersonParent = objNewValue‬‬
‫‪End Property‬‬

                                 ‫ﻣﻮاﺻﻔﺎت اﻟﺨﺼﺎﺋﺺ ‪:Property Attributes‬‬
‫ﺑﺎﻣﻜﺎﻧﻚ ﺗﻌﺪﻳﻞ ﻣﻮاﺻﻔﺎت اﻟﺨﺼﺎﺋﺺ ﻋﻦ ﻃﺮﻳﻖ ﺻﻨﺪوق اﻟﺤﻮار ‪Procedure Attributes‬‬
   ‫ـ‬     ‫ـ‬          ‫ـ‬
‫واﻟـﺬي ﺗﺼـﻞ اﻟﻴـﻪ ﻣـﻦ اﻟﻘﺎﺋﻤـﺔ ‪ Tools‬ﺑﻌـﺪ ﺗﺤﺮﻳـﻚ ﻣﺆﺷـﺮ اﻟﻜﺘﺎﺑـﺔ اﻟـﻰ ﻣﻜـﺎن اﺟـﺮاء‬
                            ‫ـ‬            ‫ـ‬          ‫ـ‬             ‫ـ‬      ‫ـ‬
‫اﻟﺨﺎﺻﻴﺔ. ﻣﻦ هﺬﻩ اﻟﻤﻮاﺻﻔﺎت: ﺟﻌﻞ اﻟﺨﺎﺻـﻴﺔ اﻓﺘﺮاﺿـﻴﺔ ‪ ،Default Propertey‬اﺧﻔـﺎء‬
   ‫ـ‬        ‫ـ‬     ‫ـ‬
‫اﻟﺨﺎﺻـﻴﺔ ﻣـﻦ ﻧﺎﻓـﺬة ﻣﺴـﺘﻌﺮض اﻟﻜﺎﺋﻨـﺎت ‪ ،Object Browser‬آﺘﺎﺑـﺔ وﺻـﻒ ﻟﻠﺨﺎﺻـﻴﺔ‬
                                            ‫ـ‬           ‫ـ‬       ‫ـ‬      ‫ـ‬   ‫ـ‬
‫....اﻟﺦ، ﺑﺎﻣﻜﺎﻧﻚ اﺳﺘﻜﺸﺎف ﺑﺎﻗﻲ اﻟﺨﻴﺎرات ﻓﻲ ﺻﻨﺪوق اﻟﺤﻮار، وﻋﻠﻴﻚ ان ﺗﻌﻠﻢ ﻋﻠـﻢ‬
‫اﻟﻴﻘﻴﻦ ان ﺟﻤﻴﻊ هﺬﻩ اﻟﺨﻴﺎرات ﺳﺘﺤﻔﻆ ﻓﻲ ﻣﻠﻒ اﻟﻔﺌﺔ ‪ .CLS‬ﻓﻘﻂ وﻟﻦ ﺗﻈﻬﺮ ﻟﻚ ﻓـﻲ‬
‫ﻧﺎﻓﺬة ﻣﺤﺮر اآﻮاد اﻟﻔﺌﺔ، ﻓﻠﻮ ﻗﻤﺖ ﺑﻌﻤﻠﻴﺔ ﻧﺴﺦ وﻟﺼﻖ اآـﻮاد اﻟﻔﺌـﺔ اﻟـﻰ ﻓﺌـﺔ اﺧـﺮى،‬
                                         ‫ﻋﻠﻴﻚ اﻋﺎدة ﻋﻤﻠﻴﺔ ﺗﺤﺮﻳﺮ ﻣﻮاﺻﻔﺎت اﻟﻔﺌﺔ.‬
                                            ‫751‬


                                                                   ‫ﺑﻨﺎء اﻟﻄﺮق‬
‫اﻟﻄﺮق ‪ Methods‬ﻣﺎهﻲ اﻻ اﺟﺮاءات ‪ Sub’s‬او دوال ‪ Function‬ﻣﻌﺮﻓﺔ داﺧﻞ اﻟﻔﺌـﺔ، وﻻ‬
‫اﻋﺘﻘﺪ اﻧﻚ ﺑﺤﺎﺟـﺔ اﻟـﻰ اﻋـﺎدة اﻟﻔﺼـﻞ اﻟﺜﺎﻟـﺚ "ﻟﻐـﺔ اﻟﺒﺮﻣﺠـﺔ ‪ "BASIC‬ﻟﺘﻔﺎﺻـﻴﻞ ﺑﻨـﺎء‬
                 ‫اﻻﺟﺮاءات واﻟﺪوال. ﻣﻊ ذﻟﻚ، هﺬا ﻣﺜﺎل ﻟﻄﺮﻳﻘﺔ ﺗﺎﺑﻌﺔ ﻟﻠﻔﺌﺔ ‪:CPerson‬‬

‫)‪Public Sub SetData(sName As String, dBirthDate As Date, sAddress As Variant‬‬
  ‫‪Me.sName = sName‬‬
  ‫‪Me.dBirthDate = dBirthDate‬‬
  ‫)0(‪Me.sAddress(0) = sAddress‬‬
  ‫)1(‪Me.sAddress(1) = sAddress‬‬
  ‫)2(‪Me.sAddress(2) = sAddress‬‬
‫‪End Sub‬‬

              ‫ﺑﺎﻣﻜﺎﻧﻚ اﺳﺘﺪﻋﺎء هﺬﻩ اﻟﻄﺮﻳﻘﺔ ﺑﺪﻻ ﻣﻦ ﺗﻌﻴﻴﻦ آﻞ ﺧﺎﺻﻴﺔ ﻋﻠﻰ ﺣﺪﻩ:‬

‫ﺑﺪﻻ ﻣﻦ ﺗﻌﻴﻴﻦ اﻟﺨﺼﺎﺋﺺ ‘‬
‫‪Turki.sName = txtName.Text‬‬
‫) ‪Turki.dBirthDate = CDate ( txtBirthDate.Text‬‬
‫‪Turki.sAddress (0) = txtAddress1.Text‬‬
‫‪Turki.sAddress (1) = txtAddress2.Text‬‬
‫‪Turki.sAddress (2) = txtAddress3.Text‬‬

‫اﺳﺘﺪﻋﻲ اﻟﻄﺮﻳﻘﺔ ‘‬
‫_ ,1‪Turki.SetData txtName, CDate(txtBirthDate), Array(txtAddress‬‬
                ‫)3‪txtAddress2, txtAddress‬‬

 ‫ﺣﺘﻰ ﻟﻮ ﻟﻢ ﺗﻘﺘﻊ ﺑﻔﻜﺮة ﺗﻌﻴﻴﻦ اﻟﺨﺼﺎﺋﺺ ﺑﺎﺳﺘﺨﺪام اﻟﻄـﺮق آﻤـﺎ ﻓـﻲ‬         ‫ﻣﻼﺣﻈﺔ:‬
 ‫اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ، ﺗﺬآﺮ ان اﺳﺘﺪﻋﺎء اﻟﻄﺮﻳﻘـﺔ اﻟﺴـﺎﺑﻘﺔ اﺳـﺮع ﺑﺨﻤـﺲ‬
 ‫ﻣﺮات ﻣﻦ ﺗﻌﻴﻴﻦ ﻗﻴﻤﺔ آﻞ ﺧﺎﺻﻴﺔ ﻋﻠﻰ ﺣﺪﻩ، وﺳـﺘﺆﺛﺮ هـﺬﻩ اﻟﺴـﺮﻋﺔ‬
            ‫آﻠﻤﺎ آﺎﻧﺖ اآﻮاد اﻟﻜﺎﺋﻦ اﺑﻌﺪ –آﻤﻜﻮﻧﺎت ‪ COM‬او ‪.DCOM‬‬
                                               ‫851‬


                                                                   ‫ﺑﻨﺎء اﻻﺣﺪاث‬
‫ﻋﻨﺪﻣﺎ ﻧﺮﺑﻂ ﺑﻴﻦ آﻠﻤﺘﻲ اﻻﺣﺪاث واﻟﻔﺌﺎت ﻳﺘﺒﺎدر ﻟﺬهﻦ ﻣﺒﺮﻣﺠـﻲ 4‪ VB‬ﺣـﺪث اﻻﻧﺸـﺎء‬
‫‪ Class_Initialize‬واﻻﻧﻬﺎء ‪ .Class_Terminates‬ﻟﻜﻦ ﻣﻊ اﻻﺻـﺪارات اﻻﺣـﺪث، اﺻـﺒﺤﺖ‬
‫اﻟﻔﺌﺎت ﻗﺎﺑﻠﺔ ﻋﻠﻰ اﻧﺸﺎء وﺗﻌﺮﻳﻒ اﺣﺪاث ﺟﺪﻳﺪة ﻗﺎﺑﻠـﺔ ﻟﻠﺘﺼـﺮﻳﺢ ﻣـﻦ اﻟﻌﻤـﻼء ‪Clients‬‬
                          ‫اﻟﻤﺴﺘﺨﺪﻣﻴﻦ ﻟﺘﻠﻚ اﻟﻔﺌﺔ –واﻟﺬﻳﻦ ﻗﺪ ﺗﻜﻮن اﻧﺖ اﺣﺪهﻢ.‬
‫اﻟﻔﻜﺮة ﻟﻴﺴﺖ ﺻﻌﺒﺔ او ﻣﺨﺘﻠﻔﺔ ﻋﻦ اﻻﺣﺪاث اﻟﻤﻮﺟﻮدة ﻓﻲ اﻻدوات، ﻟﻨﺄﺧﺬ ﻣﺜﻼ ﻧﺎﻓﺬة‬
‫اﻟﻨﻤﻮذج ‪ ،Form‬ﺗﻢ ﺗﻌﺮﻳﻒ ﺣﺪث ﻓﻴﻬﺎ ﺑﺎﺳﻢ ‪ Click‬وﻻﺷﺘﻘﺎق واﺳﺘﺨﺪام ذﻟـﻚ اﻟﺤـﺪث‬
‫آﻞ ﻣﺎ هﻮ ﻣﻄﻠﻮب ﻣﻨﻚ وﺿﻊ اﺳﻢ اﻟﻜﺎﺋﻦ ﺛﻢ ﺷﺮﻃﺔ ﺳـﻔﻠﻴﺔ وﻣـﻦ ﺛـﻢ اﺳـﻢ اﻟﺤـﺪث‬
                                                           ‫آﻤﺎ ﻓﻲ هﺬا اﻟﻜﻮد:‬

‫)(‪Private Sub Form_Click‬‬
‫اﺷﺘﻘﺎق ﺣﺪث اﻟﻨﻘﺮ ﻣﻦ آﺎﺋﻦ اﻟﻨﻤﻮذج ‘‬
‫‪End Sub‬‬

‫ﻣﻦ هﻨﺎ ﻳﺘﻀﺢ ﻟﻨـﺎ ان اﻟﺤـﺪث ﺑﻜـﻞ ﺑﺴـﺎﻃﺔ ﻋﺒـﺎرة ﻋـﻦ اﺟـﺮاء ‪ Sub‬ﻗـﺪ ﻳﺤﺘـﻮي ﻋﻠـﻰ‬
‫ﻣﺘﻐﻴــﺮات اﺿــﺎﻓﻴﺔ ‪ Parameters‬آــﺎﻟﻤﻮﺟﻮدة ﻓــﻲ ﺣــﺪث ‪ MouseDown‬او ‪.KeyPress‬‬
‫اﻟﺬي ﺳﻨﻔﻌﻠﻪ هﻨﺎ ﺑﺎﻟﻀﺒﻂ هﻮ ﺗﻌﺮﻳﻒ ﺣـﺪث ﺑﺎﺳـﻢ ‪ DataHasBeenSent‬ﻣﻮﺟـﻮد ﻓـﻲ‬
‫اﻟﻔﺌﺔ ‪ .CPerson‬وﻟﺘﻌﺮﻳﻒ هﺬا اﻟﺤﺪث اﻟﺠﺪﻳﺪ ﻓﻲ اﻟﻔﺌﺔ ﺳﻨﺴﺘﺨﺪم اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة‬
                                                                      ‫‪:Event‬‬

‫ﺗﻌﺮﻳﻒ ﺣﺪث ﺟﺪﻳﺪ ‘‬
‫)‪Event DataHasBeenSent(objTo As CPerson, bSuccess As Boolean‬‬

‫ﻟﻜﻦ ﻣﻬﻼ! ﻣﺘﻰ ﻳﺴﺘﻢ ﺗﻨﻔﻴﺬ هﺬا اﻟﺤﺪث؟ هﻞ ﺳﻴﻜﻮن ذﻟﻚ ﻋﻨﺪ اﺳـﺘﺨﺪام ﺧﺼـﺎﺋﺺ‬
‫وﻃــﺮق اﻟﻜــﺎﺋﻦ آــﻞ ﻣــﺮة؟ ام ﻋﻨــﺪﻣﺎ ﺗــﺰداد ﺷــﻬﻮة ‪ Visual Basic‬ﻟﺘﻔﺠﻴــﺮ اﻻﺣــﺪاث؟‬
‫واﻟﺠﻮاب ﻓﻲ أي وﻗـﺖ ﺗﺮﻳـﺪﻩ ﻋـﻦ ﻃﺮﻳـﻖ اﺳـﺘﺨﺪام اﻟﻌﺒـﺎرة ‪ RaiseEvent‬ﻓـﻲ داﺧـﻞ‬
                                      ‫اﻟﻔﺌﺔ. اآﺘﺐ هﺬا اﻟﻜﻮد ﻓﻲ اﻟﻔﺌﺔ ‪:CPerson‬‬

‫‪Option Explicit‬‬

‫ﺗﻌﺮﻳﻒ ﺣﺪث ﺟﺪﻳﺪ ‘‬
‫)‪Event DataHasBeenSent(objTo As CPerson, bSuccess As Boolean‬‬

‫ﺗﻌﺮﻳﻒ ﻃﺮﻳﻘﺔ ﺟﺪﻳﺪة ﻓﻲ اﻟﻔﺌﺔ ‘‬
‫)‪Public Sub SendData(objTo As CPerson‬‬
                                           ‫951‬


‫هﻨﺎ ﺳﻨﻘﻮم ﺑﺘﻔﻌﻴﻞ اﻟﺤﺪث ‘‬
   ‫‪If objTo Is Nothing Then‬‬
      ‫)‪RaiseEvent DataHasBeenSent(objTo, False‬‬
   ‫‪Else‬‬
      ‫)‪RaiseEvent DataHasBeenSent(objTo, True‬‬
   ‫‪End If‬‬
‫‪End Sub‬‬

‫واﻻن ﻧﻨﺘﻘﻞ اﻟﻰ اﻟﺠﻬﺔ اﻻﺧﺮى وﻣﻌﺮﻓﺔ آﻴﻔﻴﺔ اﻟﺘﻔﺎﻋﻞ ﻣﻊ هـﺬا اﻟﺤـﺪث آﻤـﺎ ﺗﺘﻔﺎﻋـﻞ‬
‫ﻣﻊ اﺣﺪاث اﻻدوات اﻻﺧﺮى آـ ‪ Click‬وﻏﻴﺮهﺎ، ﺗﺘﻢ اﻟﻌﻤﻠﻴﺔ ﺑﻨﻔﺲ اﻟﻄﺮﻳﻘﺔ اﻟﺘﻲ ﺗﺘﻌﺎﻣﻞ‬
                                                          ‫ﻣﻊ اﻻدوات ﺷﺮﻳﻄﺔ:‬

                    ‫اﺳﺘﺨﺪام اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ WithEvents‬ﻣﻊ ﺗﻌﺮﻳﻒ اﻟﻜﺎﺋﻦ.‬     ‫-‬
                                              ‫ﻻ ﻳﻜﻮن اﻟﻜﺎﺋﻦ ﺗﺎﺑﻊ ﻟﻤﺼﻔﻮﻓﺔ.‬   ‫-‬
                  ‫ان ﻳﺘﻢ اﻻﻋﻼن ﻋﻦ اﻟﻜﺎﺋﻦ ﻋﻠﻰ ﻣﺴﺘﻮى اﻟﻮﺣﺪة -أي ‪.Public‬‬       ‫-‬

‫ﺳﻨﻨﺸﺊ آﺎﺋﻦ ﺑﺎﺳﻢ ‪ Caller‬ﻣﻦ اﻟﻔﺌﺔ ‪ CPerson‬وﺳﻨﺤﺎول اﻻﺳﺘﺠﺎﺑﺔ ﻻﺣـﺪاث ذﻟـﻚ‬
                                 ‫اﻟﻜﺎﺋﻦ، ﻓﻲ ﻧﺎﻓﺬة اﻟﻨﻤﻮذج اآﺘﺐ هﺬا اﻟﻜﻮد:‬

‫‪Option Explicit‬‬

‫‪Dim WithEvents Caller As CPerson‬‬

‫)(‪Private Sub Form_Click‬‬
        ‫‪Dim Khaled As CPerson‬‬

       ‫‪Set Khaled = New CPerson‬‬

       ‫”ﺧﺎﻟﺪ“ = ‪Khaled.sName‬‬

      ‫‪Caller.SendData Khaled‬‬
‫‪End Sub‬‬

‫)(‪Private Sub Form_Load‬‬
  ‫‪Set Caller = New MyClass‬‬
‫‪End Sub‬‬
                                              ‫061‬



‫)‪Private Sub Caller_DataHasBeenSent(objTo As CPerson, bSuccess As Boolean‬‬
  ‫‪If bSuccess Then‬‬
     ‫‪" CPerson.sName‬ﺗﻢ ارﺳﺎل اﻟﺒﻴﺎﻧﺎت ﺑﻨﺠﺎح اﻟﻰ: " ‪MsgBox‬‬
  ‫‪Else‬‬
     ‫”ﻟﻢ اﺗﻤﻜﻦ ﻣﻦ ارﺳﺎل اﻟﺒﻴﺎﻧﺎت“ ‪MsgBox‬‬
  ‫‪End If‬‬
‫‪End Sub‬‬

 ‫ﻻ ﻳﻮﺟﺪ داﻋﻲ ﻟﻜﺘﺎﺑﺔ اﺳﻢ اﻟﺤﺪث اﻟﻄﻮﻳﻞ ﺑﻠﻮﺣـﺔ اﻟﻤﻔـﺎﺗﻴﺢ، ﻓﺒﻤﺠـﺮد‬          ‫ﻣﻼﺣﻈﺔ:‬
 ‫ﺗﻌﺮﻳﻔﻚ ﻟﻠﺴﻄﺮ اﻟﺬي ﺗﻮﺟﺪ ﺑﻪ آﻠﻤﺔ ‪ WithEvents‬اﻧﺘﻘﻞ اﻟﻰ اﻟﻘﺎﺋﻤـﺔ‬
 ‫اﻟﻤﻨﺴﺪﻟﺔ ‪ Combo Box‬ﻓﻲ اﻋﻠـﻰ ﻳﺴـﺎر ﻧﺎﻓـﺬة اﻟﺘﺤﺮﻳـﺮ ﺣﺘـﻰ ﺗـﺮى‬
 ‫اﺳــﻢ اﻟﻜــﺎﺋﻦ ‪ MyCaller‬ﻣــﻊ ﺑــﺎﻗﻲ اﺳــﻤﺎء اﻻدوات اﻟﻤﻮﺟــﻮدة ﻓــﻲ‬
                                                            ‫اﻟﻨﺎﻓﺬة.‬

‫ﻣﺜﺎل ﻣﺒﺴﻂ ﺟﺪا ﻳﻮﺿﺢ ﻃﺮﻳﻘﺔ اﻻﺳﺘﺠﺎﺑﺔ ﻟﻠﺤﺪث ‪ ،Caller_DataHasBeenSent‬اﻟﺬي‬
                                ‫ﻳﺘﻢ ﺗﻔﺠﻴﺮﻩ ﺑﻤﺠﺮد ﻧﺠﺎح اﻟﻄﺮﻳﻘﺔ ‪.SendData‬‬

                                                                    ‫اﻟﻘﺎء اﻻﺣﺪاث:‬
    ‫ـ‬      ‫ـ‬       ‫ـ‬     ‫ـ‬
‫ﻋ ـﻦ ﻃﺮﻳﻘ ـﺔ اﻟﻜﻠﻤ ـﺔ اﻟﻤﺤﺠ ـﻮزة ‪ WithEvents‬ﺗﺴ ـﺘﻄﻴﻊ ﺗﻄﺒﻴ ـﻖ ﻣﺒ ـﺪأ اﻟﻘ ـﺎء اﻻﺣ ـﺪاث‬
                                    ‫ـ‬                    ‫ـ‬      ‫ـ‬        ‫ـ‬       ‫ـ‬
‫‪ ،Event Multicasting‬وهﻲ ﻋﻤﻠﻴﺔ رﻣﻲ اﻻﺣـﺪاث ﻣـﻦ آـﺎﺋﻦ او اداة اﻟـﻰ ﻓﺌـﺔ آـﺎﺋﻦ‬
‫ﺁﺧﺮ ﺑﻤﺠـﺮد ﺗﻔﺠﻴـﺮ اﻟﺤـﺪث وﻗﺒـﻞ ان ﺗﻨﻔﻴـﺬ اآـﻮادﻩ. ﺳﺄوﺿـﺢ اﻟﻔﻜـﺮة ﺑﺎﻟﻤﺜـﺎل اﻟﻘـﺪﻳﻢ‬
‫اﻟﻤﻮﺟﻮد ﻓﻲ اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ "اﻟﻨﻤﺎذج واﻻدوات" وﺑﺎﻟﺘﺤﺪﻳﺪ ﻋﻨﺪ ﻓﻘﺮة "اﻟﺴـﻴﻄﺮة ﻋﻠـﻰ‬
‫اﻟﻤــﺪﺧﻼت" اﻟﺘﺎﺑﻌــﺔ ﻟﻔﻘــﺮة "أداة اﻟــﻨﺺ ‪ ،"TextBox‬ﺗﻼﺣــﻆ ان اﻟﻜــﻮد اﻟﻤﺴــﺘﺨﺪم‬
‫ﻟﻠﺴﻴﻄﺮة ﻋﻠﻰ اﻟﻤﺪﺧﻼت آﺎن ﻃﻮﻳـﻞ ﺟـﺪا، وﻗـﺪ اﺗﻔﻘﻨـﺎ –ﻣﻨـﺬ اﻟﺒﺪاﻳـﺔ- اﻧـﻪ ﻣـﻦ ﻏﻴـﺮ‬
‫اﻟﻤﻌﻘﻮل اﺳﺘﺨﺪام آﻞ هﺬﻩ اﻻآﻮاد ﻟﻠﺘﺤﻘﻖ ﻣﻦ اﻟﻘﻴﻤﺔ اﻟﺘﻲ ﻳﻜﺘﺒﻬﺎ اﻟﻤﺴـﺘﺨﺪم ﻓـﻲ‬
‫ﺧﺎﻧﺔ اﻟﻨﺺ، وﻟﻜﻦ هﻨﺎ ﺳﻨﺴﺘﺨﺪم اﻟﻜﻮد ﻣﺮة واﺣﺪة ﻓﻘﻂ، وﺳﻨﻀﻌﻪ ﻓـﻲ ﻓﺌـﺔ ﺑﺎﺳـﻢ‬
                                                                   ‫‪:CNumTextBox‬‬

‫اﻻداة اﻟﺘﻲ ﺳﺘﻠﻘﻲ اﺣﺪاﺛﻬﺎ اﻟﻴﻨﺎ ‘‬
‫‪Public WithEvents TextControl As TextBox‬‬

‫اآﻮاد ﺗﻤﻨﻊ اﻟﻤﺴﺘﺨﺪم ﻣﻦ آﺘﺎﺑﺔ اﻻ اﻻرﻗﺎم ‘‬
‫‪Private OldText As String‬‬
‫‪Private OldSelStart As Long‬‬
                                              161



Private Sub TextControl_GotFocus()
‘ ‫ﻋﻨﺪﻣﺎ ﻳﻜﻮن اﻟﺘﺮآﻴﺰ ﻋﻠﻰ اﻻداة‬
‘ ‫ﻻﺑﺪ ﻣﻦ ﺣﻔﻆ ﻗﻴﻤﺘﻬﺎ‬
         OldText = TextControl.Text
         OldSelStart = TextControl.SelStart
End Sub

Private Sub TextControl_Change()
        ‘ ‫ﻣﺘﻐﻴﺮ ﻳﻤﻨﻊ اﺳﺘﺪﻋﺎء اﻻﺟﺮاء ﺗﺮاﺟﻌﻴﺎ‬
        Static bExitNow As Boolean
        If bExitNow Then Exit Sub

      If Not IsNumeric(TextControl.Text) Then
              ‘ ‫اﻟﻤﻔﺘﺎح اﻟﻤﺪﺧﻞ ﻟﻴﺲ رﻗﻢ‬
              ‘ ‫ﻗﻢ ﺑﺎﻋﺎدة ﻋﺮض اﻟﻘﻴﻤﺔ اﻟﻘﺪﻳﻤﺔ‬
              bExitNow = True
              TextControl.Text = OldText
              bExitNow = False
              TextControl.SelStart = OldSelStart
      Else
              ‘ ‫اﻟﻘﻴﻤﺔ اﻟﻤﺪﺧﻠﺔ رﻗﻤﻴﺔ اذا‬
              ‘ ‫ﻗﻢ ﺑﺤﻔﻈﻬﺎ‬
              OldText = TextControl.Text
              OldSelStart = TextControl.SelStart
      End If
End Sub

Private Sub TextControl_KeyDown(KeyCode As Integer, Shift As Integer)
        OldSelStart = TextControl.SelStart
End Sub

Private Sub TextControl_KeyUp(KeyCode As Integer, Shift As Integer)
        OldSelStart = TextControl.SelStart
End Sub

Private Sub TextControl_MouseUp(Button As Integer, Shift As Integer, _
                                              ‫261‬


             ‫)‪X As Single, Y As Single‬‬
      ‫‪OldSelStart = TextControl.SelStart‬‬
‫‪End Sub‬‬

‫)(‪Private Sub TextControl_Click‬‬
        ‫‪OldSelStart = TextControl.SelStart‬‬
‫‪End Sub‬‬

‫واﻻن ﻓﻲ آﻞ ﻣﺮة ﺗﺮﻳﺪ اﻧﺸﺎء اداة ﻧﺺ ‪ TextBox‬ﺟﺪﻳﺪة ﻻ ﺗﻘﺒﻞ اﻻ اﻻﻋﺪاد، ﻓﻼ ﻳﻮﺟـﺪ‬
‫داﻋﻲ ﻟﻜﺘﺎﺑﺔ آﻞ اﻻآﻮاد اﻟﺴﺎﺑﻘﺔ، واﻧﻤﺎ ﻗﻢ ﺑﺎﻟﻘﺎء ﺟﻤﻴﻊ اﺣﺪاث اداة اﻟﻨﺺ اﻟﻰ اﻟﻔﺌﺔ:‬

‫‪Dim NumText As New CNumTextBox‬‬
‫‪Dim NumText2 As New CNumTextBox‬‬

‫)(‪Private Sub Form_Load‬‬
  ‫”0“ = 1‪Text‬‬
  ‫”0“ = 2‪Text‬‬
  ‫1‪Set NumText.TextControl = Text‬‬
  ‫2‪Set NumText2.TextControl = Text‬‬
‫‪End Sub‬‬

                  ‫ـ‬        ‫ـ‬     ‫ـ‬      ‫ـ‬
‫ﺗﻤﻜﻨ ـﺎ ﺑﺒﺴ ـﺎﻃﺔ ﺷ ـﺪﻳﺪة ﻓ ـﻲ اﻟﻜ ـﻮد اﻟﺴ ـﺎﺑﻖ ﻣ ـﻦ ﺟﻌ ـﻞ اﻻداﺗ ـﻴﻦ 1‪ Text‬و 2‪ Text‬ﻻ‬
                                                ‫ـ‬      ‫ـ‬       ‫ـ‬      ‫ـ‬      ‫ـ‬
                        ‫ﺗﻘﺒﻼن اﻻ اﻋﺪاد ﺑﻔﻀﻞ اﻟﻘﺎء اﻻﺣﺪاث ‪.Event Multicasting‬‬

                                                               ‫ﻣﺜﺎل ﺗﻄﺒﻴﻘﻲ‬
‫ﺑﺎﻣﻜﺎﻧﻚ ﺗﻄﺒﻴﻖ ﻣﺌﺎت اﻻﻣﺜﻠﺔ واﻧﺸـﺎء ﻣﺌـﺎت اﻟﻔﺌـﺎت ﺣﺘـﻰ ﺗﺠﻌـﻞ ﺣﻴﺎﺗـﻚ اﺳـﻬﻞ، اﻻ‬
              ‫اﻧﻨﻲ ﺳﺄآﺘﻔﻲ ﺑﺘﻄﺒﻴﻖ ﻣﺜﺎل ﺑﺴﻴﻂ ﺟﺪا ﻳﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﻠﻔﺎت اﻟﺜﻨﺎﺋﻴﺔ.‬

                                                                     ‫اﻟﻔﺌﺔ ‪:CFile‬‬
  ‫ـ‬           ‫ـ‬      ‫ـ ـ‬      ‫ـ‬
‫ﻗـﺪ ﺗﺘﻌﺎﻣـﻞ آﺜﻴـﺮا ﻣـﻊ اﻟﻤﻠﻔـﺎت اﻟﺜﻨﺎﺋﻴـﺔ واﻟﺘـﻲ ﺗﺘﻄﻠـﺐ دﻗـﺔ ﻓـﻲ اﺳـﺘﺨﺪام دواﻟﻬـﺎ،‬
                                      ‫ـ‬    ‫ـ‬         ‫ـ‬       ‫ـ ـ‬        ‫ـ‬
‫ﻋﺒﺎراﺗﻬﺎ واواﻣﺮهﺎ، وﺑﻜﻞ ﺗﺄآﻴﺪ اﻻﺧﻄﺎء اﻟﺼﻐﻴﺮة ﺗﺴﺒﺐ اﻟـﻰ ﺗﻐﻴﻴـﺮ هﻴﺌـﺔ اﻟﻤﻠـﻒ ﻣﻤـﺎ‬
‫ﻳﻨﺘﺞ ﻋﻨﻪ ﺷﻮاﺋﺐ واﺧﻄﺎء وﻗﺖ اﻟﺘﻨﻔﻴﺬ. ﺳﻨﺼﻤﻢ ﻓﺌﺔ ‪ CFile‬ﺗﻤﻜﻨﻨﺎ ﻣﻦ ﺗﺤﺮﻳﺮ اﻟﻤﻠﻔﺎت‬
                       ‫اﻟﺜﻨﺎﺋﻴﺔ ﺑﻄﺮﻳﻘﺔ اﺳﻬﻞ، ﻓﺒﺪﻻ ﻣﻦ آﺘﺎﺑﺔ هﺬﻩ اﻻآﻮاد اﻟﻤﻌﻘﺪة:‬
                                             ‫361‬


‫‪Dim iFree File As Integer‬‬

‫‪iFreeFile = FreeFile‬‬
‫‪Open “MyFile.TXT” For Binary As #iFreeFile‬‬

‫ﻟﻠﻜﺘﺎﺑﺔ اﻟﻰ اﻟﻤﻠﻒ ‘‬
‫”اﺳﻠﻮب اﺟﺮاﺋﻲ ﻣﻘﺮف!“ , ,1# ‪Put‬‬

‫ﻟﻠﻘﺮاءة ‘‬
‫‪Dim sTemp As String‬‬

‫)“ “ ,81( ‪sTemp = String‬‬

‫‪Get #1, , sTemp‬‬

‫‪Print sTemp‬‬
                                                      ‫ﻣﺎ رأﻳﻚ ﺑﻜﺘﺎﺑﺔ هﺬﻩ اﻻآﻮاد:‬

‫‪Dim MyFile As New CFile‬‬

‫”‪MyFile.OpenFile “MyFile.TXT‬‬
‫”اﺳﻠﻮب آﺎﺋﻨﻲ ﺟﻤﻴﻞ“ ‪MyFile.PutData‬‬
‫)61( ‪Print MyFile.GetData‬‬

‫ﻻ ﻳﻘﺘﺼﺮ اﻟﻔﺮق ﺑﻴﻦ اﻻﺳﻠﻮب اﻻﺟﺮاﺋﻲ اﻻول واﻻﺳﻠﻮب اﻟﻜﺎﺋﻨﻲ اﻟﺜﺎﻧﻲ ﻋﻠﻰ اﺧﺘﺼـﺎر‬
‫ﻋﺪد ﺳﻄﻮر اﻻآﻮاد ﻓﻘﻂ، ﺑﻞ ﺣﺘﻰ ﻓﻲ ﺣﺎﻻت ﻧﺴﻴﺎن آﺘﺎﺑـﺔ اﻻواﻣـﺮ اﻟﻀـﺮورﻳﺔ، ﻓﻤـﺜﻼ‬
‫ﺗﻼﺣﻆ اﻧﻨﻲ ﻟﻢ اﻏﻠﻖ اﻟﻤﻠﻒ ﺑﺎﺳﺘﺨﺪام اﻻﻣﺮ ‪ Close‬ﻣﻤﺎ ﻳﺆدي اﻟـﻰ اﺣﺘﺠـﺎز ﻣﺴـﺎﺣﺔ‬
‫ﺑﺎﻟﺬاآﺮة، اﺿﻒ اﻟﻰ ذﻟﻚ اﺣﺘﺠﺎز رﻗﻢ اﻟﻤﻠﻒ وﻋﺪم اﻣﻜﺎﻧﻴﺔ اﺳﺘﺨﺪاﻣﻪ ﻟﻔﺘﺢ ﻣﻠﻒ ﺁﺧﺮ.‬
  ‫ـ‬                                            ‫ـ‬
‫اﻣـﺎ ﻣـﻊ اﻻﺳـﻠﻮب اﻟﻜـﺎﺋﻨﻲ، ﻓـﻼ ﻳﻮﺟـﺪ داﻋـﻲ ﻻن اﻏﻠـﻖ اﻟﻤﻠـﻒ ﺑﺎﺳـﺘﺪﻋﺎء اﻟﻄﺮﻳﻘـﺔ‬
‫‪ ،CloseFile‬ﻻن اﻟﻜﺎﺋﻨﺎت ﻣﻦ اﻟﻨﻮع ‪ CFile‬ﺗﻘـﻮم ﺑـﺎﻏﻼق ﻣﻠﻔﺎﺗﻬـﺎ ﺗﻠﻘﺎﺋﻴـﺎ ﺑﻤﺠـﺮد ﻣـﻮت‬
                         ‫اﻟﻜﺎﺋﻦ، ﻓﻬﺬا اﻟﻜﻮد ﻗﺪ اﺿﻔﺘﻪ ﻓﻲ ﺣﺪث اﻟﺘﺪﻣﻴﺮ ﻟﻠﻔﺌﺔ ‪:CFile‬‬

‫)(‪Private Sub Class_Terminate‬‬
   ‫‪Me.CloseFile‬‬
‫‪End Sub‬‬
                                             164


                   :‫ اﻟﺨﺎﺻﺔ ﺑﺎﻏﻼق اﻟﻤﻠﻒ‬CloseFile ‫اﻟﺬي ﻳﻘﻮم ﺑﺎﺳﺘﺪﻋﺎء اﻟﻄﺮﻳﻘﺔ‬

Public Sub CloseFile()
  If Me.iFileNum Then
      Close #iFileNum
      m_iFileNum = 0
  End If
End Sub

‫ وﻗـﺪ ﺗﻀـﻴﻒ‬CFile.CLS ‫ﺳﺘﺠﺪ اﻟﻜﺜﻴـﺮ ﻣـﻦ اﻟﺨﺼـﺎﺋﺺ اﻟﺘـﻲ ﻗـﺪ اﺿـﻔﺘﻬﺎ ﻓـﻲ اﻟﻤﻠـﻒ‬
‫ اﻟﺘـﻲ ﺗﺤـﺪد‬lCursorLoc ‫ﻋﺸﺮات اﻟﺨﺼﺎﺋﺺ ﺑﻘﺪر ﻣﺎ ﻳﺤﻠﻮ ﻟﻚ. ﺧﺬ ﻣﺜﻼ هﺬﻩ اﻟﺨﺎﺻﻴﺔ‬
                                   :‫ﻣﻮﻗﻊ ﻣﺆﺷﺮ اﻟﻘﺮاءة واﻟﻜﺘﺎﺑﺔ ﻣﻦ واﻟﻰ اﻟﻤﻠﻒ‬

Public Property Get lCursorLoc() As Long
  lCursorLoc = Seek(Me.iFileNum)
End Property

Public Property Let lCursorLoc(ByVal lNewValue As Long)
  Seek Me.iFileNum, lNewValue
End Property

                                                    :‫هﺬﻩ اﻣﺜﻠﺔ ﻋﻠﻰ اﺳﺘﺨﺪاﻣﻬﺎ‬

MyFile.lCursorLoc = 1               ‘ ‫ﺑﺪاﻳﺔ اﻟﻤﻠﻒ‬
MyFile.lCursorLoc = MyFile.lLOF     ‘ ‫ﻧﻬﺎﻳﺔ اﻟﻤﻠﻒ‬

             .CFile ‫ ﺣﺘﻰ ﺗﺤﺼﻞ ﻋﻠﻰ اﻻﻧﺠﺎز اﻟﻜﺎﻣﻞ ﻟﻠﻔﺌﺔ‬Codes.ZIP ‫راﺟﻊ اﻟﻤﻠﻒ‬
                                              ‫561‬


                                                               ‫اﺳﺘﺨﺪام اﻟﻜﺎﺋﻨﺎت‬
‫ﺗﻌﺮﻓﺖ ﻓﻲ اﻟﺼﻔﺤﺎت اﻟﺴﺎﺑﻘﺔ ﻋﻠﻰ اﻟﻔﺌﺎت واﻟﻔﻜﺮة ﻣﻨﻬـﺎ وآﻴﻔﻴـﺔ ﺑﻨﺎﺋﻬـﺎ، واﻻن ﺣـﺎن‬
‫دور اﺳﺘﺨﺪام اﻟﻔﺌﺎت واﻧﺸﺎء اﻟﻜﺎﺋﻨﺎت ﻣﻨﻬﺎ واﻟﺘﻌﺮف ﻋﻠـﻰ ﺑﻌـﺾ اﻟﺘﻔﺎﺻـﻴﻞ اﻟﻤﺘﻌﻠﻘـﺔ‬
                                                                     ‫ﺑﺎﻟﻜﺎﺋﻨﺎت.‬

                                       ‫ﻋﺒﺎرات وآﻠﻤﺎت ﺧﺎﺻﺔ ﺑﺎﻟﻜﺎﺋﻨﺎت‬
‫ﻣﻦ اﻟﻀـﺮوري اﻟﺘﻌـﺮف ﻋﻠـﻰ اﻟﻌﺒـﺎرات واﻟﻜﻠﻤـﺎت اﻟﻤﺤﺠـﻮزة اﻟﺨﺎﺻـﺔ ﺑﺎﻟﻜﺎﺋﻨـﺎت ﺣﺘـﻰ‬
‫ﺗﺴﺘﺨﺪﻣﻬﺎ اﻻﺳﺘﺨﺪام اﻻﻣﺜﻞ، ﻧﺒﺪأ ﻣﻊ اﻧﺸﺎء اﻟﻜﺎﺋﻨﺎت ﺑﺎﺳﺘﺨﺪام اﻟﻜﻠﻤـﺔ اﻟﻤﺤﺠـﻮزة‬
                                                                         ‫‪:New‬‬

                                                       ‫اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪:New‬‬
‫ﻗﺒﻞ اﺳﺘﺨﺪام اﻟﻜﺎﺋﻦ ﻋﻠﻴﻚ ﺑﻜﻞ ﺗﺄآﻴﺪ اﻧﺸﺎء ﻧﺴﺨﺔ ‪ Instance‬ﻣﻨـﻪ، ﻳﻤﻜﻨـﻚ ‪Visual‬‬
   ‫ـ‬     ‫ـ‬                              ‫ـ‬          ‫ـ‬     ‫ـ‬          ‫ـ‬      ‫ـ‬
‫‪ Basic‬ﻣ ـﻦ اﻧﺸ ـﺎء اﻟﻜﺎﺋﻨ ـﺎت ﺑ ـﺪاﻟﺘﻴﻦ هﻤ ـﺎ ‪ CreateObject‬و ‪ GetObject‬وﻟ ـﻦ اﺗﺤ ـﺪث‬
‫ﻋﻨﻬﻤﺎ اﻻ ﻓﻲ اﻟﻔﺼـﻞ اﻟﺜـﺎﻧﻲ ﻋﺸـﺮ "ﺑﺮﻣﺠـﺔ اﻟﻤﻜﻮﻧـﺎت ‪ ،"1 COM‬واﻟﻄﺮﻳﻘـﺔ اﻻﺧـﺮى‬
‫اﻟﺘﻲ ﺗﻤﻜﻨﻚ ﻣﻦ اﻧﺸﺎء اﻟﻜﺎﺋﻨﺎت هﻲ ﺑﺎﺳـﺘﺨﺪام اﻟﻜﻠﻤـﺔ اﻟﻤﺤﺠـﻮزة ‪ New‬ﺳـﻮاء ﻣـﻊ‬
                                                 ‫ﺗﺼﺮﻳﺢ اﻟﻜﺎﺋﻦ او ﻣﻊ اﻟﻌﺒﺎرة ‪:Set‬‬

‫‪Dim Turki As New CPerson‬‬
‫‪Dim Khaled As CPerson‬‬
‫‪Set Khaled = New CPerson‬‬

‫ﻣﻦ اﻻﺷﻴﺎء اﻟﻌﺠﻴﺒﺔ ﺟﺪا ﺟﺪا واﻟﺘﻲ ﺗﻐﺎﻟﻂ اﻟﻤﻨﻄﻖ اﻟﺒﺮﻣﺠﻲ، ان ﻋﻤﻠﻴﺔ اﻧﺸﺎء اﻟﻜﺎﺋﻦ‬
‫ﺑﺎﺳﺘﺨﺪام اﻟﻜﻠﻤـﺔ ‪ New‬ﻓـﻲ ﻧﻔـﺲ وﻗـﺖ اﻟﺘﺼـﺮﻳﺢ –أي ﻣـﻊ ﻋﺒـﺎرة ‪ Dim‬ﻣﺜـﻞ اﻟﻜـﻮد‬
‫اﻟﺴﺎﺑﻖ- ﻻ ﺗﺆدي اﻟﻰ ﺗﻔﺠﻴﺮ ﺣﺪث اﻻﻧﺸﺎء ‪ Class_Initialize‬اﻟﺘﺎﺑﻊ ﻟﻠﻜﺎﺋﻦ! وﻟـﻦ ﻳـﺘﻢ‬
‫ﺗﻔﺠﻴﺮﻩ ﺣﺘﻰ ﺗﺴﺘﺨﺪم اﻟﻜﺎﺋﻦ ﻓﻲ اآﻮادك. واﻟﺴﺒﺐ اﻟﻐﺮﻳﺐ ﺟﺪا –ﺑﺎﻟﻨﺴـﺒﺔ ﻟـﻲ- هـﻮ‬
‫ان ‪ Visual Basic‬ﻟﻦ ﻳﻘﻮم ﻓﻌﻠﻴﺎ ﺑﺎﻧﺸﺎء اﻟﻜﺎﺋﻦ ﺣﺘﻰ ﺗﺬآﺮﻩ وﺗﺴـﺘﺨﺪﻣﻪ ﻓـﻲ اآـﻮادك،‬
             ‫ﺑﺎﻟﺮﻏﻢ ﻣﻦ اﻧﻨﺎ اﺳﺘﺨﺪﻣﻨﺎ اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ New‬ﻋﻨﺪ اﻟﺘﺼﺮﻳﺢ ﻻﻧﺸﺎءﻩ!‬

                                                                  ‫اﻟﻌﺒﺎرة ‪:Set‬‬
                             ‫ﺗﺴﺘﺨﺪم اﻟﻌﺒﺎرة ‪ Set‬ﻓﻲ اﻟﻌﺎدة ﻻﺳﻨﺎد آﺎﺋﻦ اﻟﻰ ﺁﺧﺮ:‬

‫‪Set Khaled = Turki‬‬
                                              ‫661‬


‫ﻣﻦ اﻟﻀﺮوري اﺳﺘﺨﺪام اﻟﻌﺒﺎرة ‪ Set‬ﻋﻨﺪ اﺳﻨﺎد اﻟﻜﺎﺋﻨﺎت، ﻻﻧـﻚ ان ﻟـﻢ ﺗﺴـﺘﺨﺪﻣﻬﺎ ﻗـﺪ‬
‫ﺗﻈﻬﺮ ﻟﻚ رﺳﺎﻟﺔ ﺧﻄﺄ او ﺣﺘﻰ ﻧﺘـﺎﺋﺞ ﻏﻴـﺮ ﻣﺘﻮﻗﻌـﺔ، ﻓﻠـﻮ اﻓﺘﺮﺿـﻨﺎ ان اﻟﻜـﺎﺋﻨﻴﻦ ‪ Turki‬و‬
‫‪ Khaled‬ﻟﻬﻤﺎ ﺧﺎﺻﻴﺔ اﻓﺘﺮاﺿﻴﺔ واﺣﺪة هﻲ ‪ ،sName‬وﻗﻤﺖ ﺑﺎﺳﻨﺎد ﻗﻴﻤﺔ اﻟﻜﺎﺋﻦ اﻻول‬
                                               ‫اﻟﻰ اﻟﺜﺎﻧﻲ دون اﺳﺘﺨﺪام اﻟﻌﺒﺎرة ‪:Set‬‬

‫‪Khaled = Turki‬‬

‫ﻓﺎﻧﻚ ﻓﻲ اﻟﺤﻘﻴﻘﺔ ﻟﻢ ﺗﺴﻨﺪ اﻻ ﻗﻴﻤﺔ ﺧﺎﺻـﻴﺔ اﻟﻜـﺎﺋﻦ اﻻول اﻻﻓﺘﺮاﺿـﻴﺔ اﻟـﻰ اﻟﺨﺎﺻـﻴﺔ‬
                       ‫اﻻﻓﺘﺮاﺿﻴﺔ ﻟﻠﻜﺎﺋﻦ اﻟﺜﺎﻧﻲ، أي ان ﺣﻘﻴﻘﺔ اﻟﻜﻮد اﻟﺴﺎﺑﻖ هﻲ:‬

‫‪Khaled.sName = Turki.sName‬‬

                                                                  ‫اﻟﻤﻌﺎﻣﻞ ‪:Is‬‬
      ‫ﺗﺴﺘﺨﺪم هﺬا اﻟﻤﻌﺎﻣﻞ ﻟﻤﻌﺮﻓﺔ ﻣﺎ اذا آﺎﻧﺎ اﻟﻤﺘﻐﻴﺮان ﻳﺸﻴﺮان اﻟﻰ ﻧﻔﺲ اﻟﻜﺎﺋﻦ:‬

‫… ‪If Khaled Is Turki Then‬‬

                   ‫وﻳﻤﻜﻨﻚ اﻳﻀﺎ ﻣﻌﺮﻓﺔ ﻣﺎ اذا آﺎن اﻟﻜﺎﺋﻦ ﺣﻲ ﻳﺮزق وﻳﺘﺒﻊ ﻟﻔﺌﺔ او ﻻ:‬

‫… ‪If Khaled Is Nothing Then‬‬

‫اﻣــﺎ ﻣﻌﺎﻣــﻞ اﻟﻤﺴــﺎواة ﻓــﺎرﺟﻮ ان ﺗﻨﺴــﻰ ﻓﻜــﺮة اﺳــﺘﺨﺪاﻣﻪ ﻟﻠﺘﺤﻘــﻖ ﻣــﻦ ﻣﺴــﺎواة‬
                                                          ‫اﻟﻜﺎﺋﻨﺎت، ﻓﺎﻟﻜﻮد اﻟﺘﺎﻟﻲ:‬

‫… ‪If Khaled = Turki Then‬‬

                 ‫ﻻ ﻳﻘﺎرن اﻻ اﻟﺨﺼﺎﺋﺺ اﻻﻓﺘﺮاﺿﻴﺔ -ان وﺟﺪت- ﻟﻠﻜﺎﺋﻨﺎت، وآﺄﻧﻚ آﺘﺒﺖ:‬

‫… ‪If Khaled.sName = Turki.sName Then‬‬

                                                          ‫اﻟﻌﺒﺎرة ‪:TypeOf … Is‬‬
                         ‫ﺗﻤﻜﻨﻚ هﺬﻩ اﻟﻌﺒﺎرة ﻣﻦ اﺧﺘﺒﺎر ﻧﻮع اﻟﻔﺌﺔ اﻟﺘﻲ ﺗﻤﺜﻞ اﻟﻜﺎﺋﻦ:‬

‫… ‪If TypeOf Turki Is CPerson Then‬‬
                                            ‫761‬


‫‪If TypeOf MyCtrl Is TextBox Then‬‬
       ‫”…“ = ‪MyCtrl.Text‬‬
‫‪Else‬‬
       ‫”…“ = ‪MyCtrl.Caption‬‬
‫‪End If‬‬

                                                          ‫اﻟﺪاﻟﺔ ‪:TypeName‬‬
           ‫اﻟﺪاﻟﺔ ‪ TypeName‬ﺗﻌﻮد ﺑﻘﻴﻤﺔ ﺣﺮﻓﻴﺔ ﺗﻤﺜﻞ اﺳﻢ اﻟﻔﺌﺔ اﻟﺘﺎﺑﻊ ﻟﻬﺎ اﻟﻜﺎﺋﻦ:‬

‫)‪Print TypeName(Turki‬‬        ‫‪‘ CPerson‬‬
‫)1‪Print TypeName(Text‬‬        ‫‪‘ TextBox‬‬

                                                         ‫اﻟﻘﻴﻤﺔ ‪:Nothing‬‬
              ‫ﺑﺎﻣﻜﺎﻧﻚ اﻟﻐﺎء اﻟﻜﺎﺋﻦ ﻓﻲ أي وﻗﺖ ﺑﻤﺠﺮد اﺳﻨﺎد اﻟﻘﻴﻤﺔ ‪ Nothing‬اﻟﻴﻪ:‬

‫‪Set Khaled = Nothing‬‬

                            ‫اﻟﻤﺰﻳﺪ ﻣﻦ اﻟﺘﻔﺎﺻﻴﻞ ﺣﻮل ﻣﻮت اﻟﻜﺎﺋﻨﺎت ﺳﺘﻘﺮأهﺎ ﻗﺮﻳﺒﺎ.‬

                                                  ‫ﻣﺎهﻲ ﺣﻘﻴﻘﺔ اﻟﻜﺎﺋﻦ؟‬
‫ﻓﻲ اﻟﺒﺪاﻳﺔ اود ان اﻋﺮف ﻣﺎهﻮ اﻟﻜﺎﺋﻦ -ﻣﺘﻐﻴﺮ اﻟﻜﺎﺋﻦ ان ﺻﺢ اﻟﺘﻌﺒﻴﺮ- ﻳﺎ ﺗﺮى؟ واﻟﺠـﻮاب‬
‫ﺑﻜﻞ ﺑﺴﺎﻃﺔ: ﻣﺘﻐﻴـﺮ اﻟﻜـﺎﺋﻦ ﻋﺒـﺎرة ﻋـﻦ ﻣﻨﻄﻘـﺔ ﻣﻮﺟـﻮدة ﻓـﻲ اﻟـﺬاآﺮة ﺗﺤﻤـﻞ ﺑﻴﺎﻧـﺎت‬
‫ﺗﺘﻌﻠﻖ ﺑﺬﻟﻚ اﻟﻜﺎﺋﻦ. ﻗﺪ ﺗﻜﻮن اﺟﺎﺑـﺔ اﻟﺴـﺆال ﻣﺴـﺘﻨﺒﻄﺔ ﻣـﻦ ﻣﺒـﺪأ ﺗﻌﺮﻳـﻒ اﻟﺘﺮآﻴﺒـﺎت‬
‫‪ UDT‬اﻻ ان اﻻﺟﺎﺑﺔ اﻟﺴﺎﺑﻘﺔ ﻣﻊ اﻻﺳﻒ اﻟﺸﺪﻳﺪ ﺧﺎﻃﺌﺔ 001% ! ﻓﻤﺘﻐﻴﺮ اﻟﻜﺎﺋﻦ ﻣﻬﻤﺎ‬
‫آﺎن ﻧﻮﻋﻪ ﻓﺎن ﺣﺠﻤﻪ ﻻ ﻳﺰﻳﺪ ﻋﻦ 4 ﺑﺎﻳﺖ )ﻓﻲ ﻧﻈـﻢ 23 ﺑـﺖ( ﻻﻧـﻪ ﻋﺒـﺎرة ﻋـﻦ ﻣﺆﺷـﺮ‬
   ‫اﻟﻰ ﻣﻨﻄﻘﺔ ﻓﻲ اﻟﺬاآﺮة ﺗﺤﻤﻞ ﺑﻴﺎﻧﺎت ﺗﺘﻌﻠﻖ ﺑﺬﻟﻚ اﻟﻜﺎﺋﻦ واﻟﺪﻟﻴﻞ راﻗﺐ هﺬا اﻟﻜﻮد:‬

‫‪Dim X As New MyClass‬‬
‫‪Dim Y As New MyClass‬‬

‫اﻟﻤﺆﺷﺮان ‘‬
‫‪‘ X, Y‬‬
‫ﻳﺸﻴﺮان اﻟﻰ ﻧﻔﺲ اﻟﻜﺎﺋﻦ ‘‬
‫‪Set Y = X‬‬
                                            ‫861‬


‫001 = ‪Y.Value‬‬

‫001 = ‪‘ Y.Value‬‬
‫‪Print Y.Value‬‬

‫002 = ‪X.Value‬‬

‫!! 002 = ‪‘ Y.Value‬‬
‫‪Print Y.Value‬‬

‫ﻋﻨﺪﻣﺎ ﻳﺘﻢ ﺗﻨﻔﻴﺬ اﻟﺴﻄﺮ ‪ Set Y = X‬ﻓﺎن اﻟﻤﻨﻄﻘﺔ ﻣـﻦ اﻟـﺬاآﺮة اﻟﺘـﻲ آـﺎن ﻳﺸـﻴﺮ ﻟﻬـﺎ‬
       ‫ـ‬     ‫ـ‬        ‫ـ‬          ‫ـ‬
‫اﻟﻤﺘﻐﻴـﺮ -اﻟﻤﺆﺷـﺮ- ‪ X‬اﺻـﺒﺤﺖ ﻧﻔـﺲ اﻟﻤﻨﻄﻘـﺔ اﻟﺘـﻲ ﻳﺸـﻴﺮ ﻟﻬـﺎ اﻟﻤﺘﻐﻴـﺮ -اﻟﻜـﺎﺋﻦ- ‪Y‬‬
                                       ‫ـ‬        ‫ـ‬       ‫ـ‬      ‫ـ‬        ‫ـ‬
‫واﻟﺪﻟﻴﻞ ﻋﻠﻰ ذﻟﻚ، اﻧﻨﻲ ﻋﻨـﺪﻣﺎ ﻗﻤـﺖ ﺑﺘﻌـﺪﻳﻞ ﻗﻴﻤـﺔ اﻟﺨﺎﺻـﻴﺔ 002 = ‪ X.Value‬ﻓـﺎن‬
‫اﻟﺨﺎﺻﻴﺔ ‪ Y.Value‬ﺗﺄﺛﺮت ﺑﺴﺒﺐ اﻟﺘﻌﺪﻳﻞ وذﻟﻚ ﻻن ‪ X‬و ‪ Y‬ﻣﺘﻐﻴﺮان )آﺎﺋﻨـﺎن، ﻣﺆﺷـﺮان(‬
‫ﻳﺸﻴﺮان اﻟﻰ ﻧﻔﺲ اﻟﻤﻨﻄﻘﺔ ﻣﻦ اﻟﺬاآﺮة اﻟﺘﻲ ﺗﺤﺘﻮي ﻋﻠـﻰ ﺑﻴﺎﻧـﺎت ﺗﺘﻌﻠـﻖ ﺑﺎﻟﻜـﺎﺋﻦ ‪X‬‬
‫وﻟﻴﺲ ﻣﻨﻄﻘﺘﻴﻦ ﻣﺨﺘﻠﻔﺘﻴﻦ. وﺑﻜﻞ ﺗﺄآﻴﺪ ﺳﺘﺴﺄل ﻧﻔﺴـﻚ ﻋـﻦ اﻟﻤﻨﻄﻘـﺔ اﻟﺘـﻲ آﺎﻧـﺖ‬
‫ﻣﺨﺼﺼﺔ ﻟﻠﻜﺎﺋﻦ ‪ Y‬ﻣﺎ هﻲ اﺧﺒﺎرهﺎ ﻳﺎ ﺗﺮى؟ اﺧﺒﺎرهﺎ ﻳﺎ ﻗﺎرﺋﻲ اﻟﻌﺰﻳـﺰ ﻓـﻲ اﻟﻤﺸـﻤﺶ!‬
   ‫ﻻﻧﻬﺎ ﻗﺪ اﺧﺘﻔﺖ ﻣﻦ اﻟﺬاآﺮة واﻧﺘﻬﺖ أي ﺑﻌﺒﺎرة ﻟﻐﻮﻳﺔ ﻣﺎﺗﺖ وﺳﺘﻌﺮف اﻟﺴﺒﺐ ﻻﺣﻘﺎ.‬

                                              ‫ﺻﻮرة اﻟﻜﺎﺋﻦ ﻓﻲ اﻟﺬاآﺮة‬
‫اﻟﻜﺎﺋﻨﺎت ﻟﻴﺴﺖ آﺎﻟﻤﺘﻐﻴﺮات اﻟﻌﺎدﻳﺔ ﻓﻬﻲ ﺗﺤﺠﺰ ﻟﻨﻔﺴﻬﺎ ﻣﻨﻄﻘﺘﻴﻦ ﻓﻲ اﻟﺬاآﺮة اﻻوﻟﻰ‬
‫ﺧﺎﺻﺔ ﻟﻤﺆﺷﺮ ﺑﻴﺎﻧـﺎت اﻟﻜـﺎﺋﻦ ﻓـﻲ اﻟـﺬاآﺮة -ﺣﺠﻤـﻪ 4 ﺑﺎﻳـﺖ- واﻟﺜﺎﻧﻴـﺔ ﺧﺎﺻـﺔ ﻟﺒﻴﺎﻧـﺎت‬
‫اﻟﻜﺎﺋﻦ ﻧﻔﺴﻪ. اﻣﺎ ﻋﻨﺪﻣﺎ ﺗﻌﻠﻦ ﻋـﻦ ﻣﺘﻐﻴـﺮ ﻋـﺎدي آــ ‪ Integer‬او ‪ Long‬ﻓـﻼ ﻧﺤﺘـﺎج اﻻ‬
‫ﻟﻤﻨﻄﻘﺔ واﺣﺪة ﺑﺎﻟﺬاآﺮة ﺧﺎﺻـﺔ ﺑﻘﻴﻤـﺔ اﻟﻤﺘﻐﻴـﺮ ﺑﺎﺳـﺘﺜﻨﺎء اﻟﻤﺘﻐﻴـﺮات ﻣـﻦ ﻧـﻮع ‪String‬‬
                                 ‫ﻓﻬﻲ ﺗﺤﺘﺎج اﻟﻰ ﻣﻨﻄﻘﺘﻴﻦ ﻣﻦ اﻟﺬاآﺮة ﻣﺜﻞ اﻟﻜﺎﺋﻨﺎت.‬
‫اﻟﻤﻨﻄﻘﺔ اﻟﺜﺎﻧﻴﺔ اﻟﺘﻲ ﻳﺤﺘﺠﺰهﺎ اﻟﻜﺎﺋﻦ ﺗﻌﺮف ﺑﻤﻨﻄﻘﺔ ﻧﺴﺨﺔ اﻟﺒﻴﺎﻧﺎت ‪Instance Data‬‬
‫‪ Area‬واﻟﻤﻘﺴﻤﺔ اﻟﻰ ﺛﻼﺛﺔ اﻗﺴـﺎم: ﻗﺴـﻢ ﺧـﺎص ﺑﺎﻟﻤﺆﺷـﺮ ‪ ،VTable‬وﻗﺴـﻢ ﺧـﺎص‬
‫ﺑﺎﻟﻌﺪاد ‪ ،Counter‬وﻗﺴﻢ ﺧـﺎص ﺑـﺎﻟﻤﺘﻐﻴﺮات اﻟﺘﺎﺑﻌـﺔ ﻟﻠﻜـﺎﺋﻦ ‪ .Data Area‬وﻓﻴﻤـﺎ ﻳﻠـﻲ‬
                                                             ‫ﺗﻔﺎﺻﻴﻞ هﺬﻩ اﻻﻗﺴﺎم:‬

                                                         ‫اﻟﻤﺆﺷﺮ ‪:VTable‬‬
‫ﺗﻔﺎﺻﻴﻞ هﺬا اﻟﻤﺆﺷﺮ ﻻﺗﻬﻢ ﻣﺒﺮﻣﺠـﻲ ‪ Visual Basic‬ﺑﻘـﺪر ﻣـﺎ ﺗﻬـﻢ ﻣﺒﺮﻣﺠـﻲ ‪ COM‬و‬
‫++‪ ،C‬ﻟﻜﻦ ﻣﺎ اﺳﺘﻄﻴﻊ ﻗﻮﻟﻪ هﻮ ان ‪ VTable‬ﻋﺒﺎرة ﻋﻦ ﻣﺆﺷﺮ اﻟﻰ ﺗﺮآﻴﺐ ﻓﻲ ﻣﻨﻄﻘﺔ‬
‫اﺧﺮى ﺑﺎﻟﺬاآﺮة ﺗﻤﺜﻞ ﻣﻮاﻗﻊ ﺗﻨﻔﻴﺬ اﻻﺟﺮاءات -اﻟﻄﺮق ‪ -Methods‬وﺑﺪاﻳﺔ آﻞ اﺟﺮاء ﺣﺘﻰ‬
                                                ‫961‬


‫ﻳﺘﻢ ﺗﻨﻔﻴﺬ اآﻮادﻩ. آﻞ ﻣﺆﺷﺮات ‪ VTable‬اﻟﺘﺎﺑﻌﺔ ﻟﻠﻜﺎﺋﻨـﺎت ﺗﺸـﻴﺮ اﻟـﻰ ﻧﻔـﺲ اﻟﺘﺮآﻴـﺐ‬
‫ﻓﻲ ﺣﺎﻟﺔ آﻮن اﻟﻜﺎﺋﻨﺎت ﻣﻦ ﻧﻔـﺲ اﻟﻔﺌـﺔ. ﻓﻠﻜـﻞ ﻓﺌـﺔ ﺟـﺪول ‪ VTable‬ﻣﺴـﺘﻘﻞ ﺧـﺎص‬
‫ﺑــﺎﺟﺮاءات ﺗﻠــﻚ اﻟﻔﺌــﺔ، وﻟﻜــﻞ آــﺎﺋﻦ ﻣﺆﺷــﺮ ﺧــﺎص ﺑــﻪ ﻳﺸــﻴﺮ اﻟــﻰ اﻟﺘﺮآﻴــﺐ ‪VTable‬‬
                                             ‫اﻟﻤﺘﻮاﻓﻖ ﻣﻊ اﻟﻔﺌﺔ اﻟﻤﻨﺸﺄ ﻣﻨﻬﺎ، ﻓﻬﻨﺎ:‬

‫‪Dim X As MyClass, Y As MyClass, Z As YourClass‬‬

‫ﺗﻮﺟﺪ ﺛﻼث ﻣﺆﺷﺮات ‪ VTable‬ﺧﺎﺻﺔ ﻟﻠﻜﺎﺋﻨﺎت ‪ X‬و ‪ Y‬و ‪ Z‬ﺗﺸـﻴﺮ اﻟـﻰ ﺗـﺮآﻴﺒﻴﻦ ‪VTable‬‬
                                         ‫ﺧﺎﺻﻴﻦ ﻟﻠﻔﺌﺘﻴﻦ ‪ MyClass‬و ‪.YourClass‬‬

                                                             ‫اﻟﻌﺪاد ‪:Counter‬‬
‫اﻟﻘﺴﻢ اﻟﺜﺎﻧﻲ ﻣﻦ هﺬﻩ اﻟﻤﻨﻄﻘﺔ ﺣﺠﻤـﻪ 4 ﺑﺎﻳـﺖ وهـﻮ ﻋﺒـﺎرة ﻋـﻦ ﻋـﺪاد ﻳﻤﺜـﻞ ﻋـﺪد‬
‫اﻟﻤﺆﺷﺮات اﻟﺘﻲ ﺗﺸﻴﺮ اﻟﻰ هﺬﻩ اﻟﻤﻨﻄﻘﺔ. ﻳﺒﺪأ اﻟﻌـﺪاد ﺑﺎﻟﻘﻴﻤـﺔ واﺣـﺪ ﻋﻨـﺪﻣﺎ ﺗﻨﺸـﺊ‬
‫اﻟﻜﺎﺋﻦ، وﻳﺰﻳﺪ آﻠﻤﺎ وﺟﺪ ﻣﺆﺷﺮ اﺧﺮ ﻳﺸﻴﺮ اﻟﻰ ذﻟـﻚ اﻟﻌـﺪاد. ﻋﻨـﺪﻣﺎ ﻳﺼـﻞ اﻟﻌـﺪاد اﻟـﻰ‬
‫اﻟﺼﻔﺮ )أي ﻻ ﻳﻮﺟﺪ ﻣﺆﺷﺮ ﻳﺸﻴﺮ اﻟﻰ ﺗﻠﻚ اﻟﻤﻨﻄﻘﺔ( ﻓـﺎن اﻟﻤﻨﻄﻘـﺔ ﻳـﺘﻢ ﺗﺤﺮﻳﺮهـﺎ ﻣـﻦ‬
          ‫اﻟﺬاآﺮة وﺗﺨﺘﻔﻲ، وهﺬا ﺟﻮاب واﺿﺢ ﻟﻠﺴﺆال ﻣﺘﻰ ﻳﻤﻮت اﻟﻜﺎﺋﻦ؟ راﻗﺐ هﻨﺎ:‬

‫‪Dim X As MyClass, Y As MyClass‬‬

‫اﻟﻌﺪاد ﻳﺒﺪأ ﺑﻮاﺣﺪ ‘‬
‫‪Set X = New MyClass‬‬
‫واﻻن اﻟﻌﺪاد ﺑﺎﺛﻨﺎن ﺑﺴﺒﺐ ‘‬
‫وﺟﻮد ﻣﺆﺷﺮان ﻳﺸﻴﺮان اﻟﻰ ‘‬
‫ﻧﻔﺲ اﻟﻤﻨﻄﻘﺔ ‘‬
‫‪Set Y = X‬‬
‫اﻟﻌﺪاد اﻻن ﻳﻨﻘﺺ ﺑﻮاﺣﺪ ‘‬
‫‪Set X = Nothing‬‬
‫اﻟﻌﺪاد اﻻن ﺑﺼﻔﺮ ﻣﻤﺎ ﻳﺆدي اﻟﻰ ‘‬
‫ﻣﻮت اﻟﻜﺎﺋﻦ ‘‬
‫‪Set Y = Nothing‬‬

                                                      ‫ﻣﻨﻄﻘﺔ اﻟﺒﻴﺎﻧﺎت ‪:Data Area‬‬
       ‫ـ‬              ‫ـ‬          ‫ـ‬         ‫ـ‬
‫وه ـﻲ اﻟﻤﻨﻄﻘ ـﺔ اﻟﺘ ـﻲ ﺗﺤﺘ ـﻮي ﻋﻠ ـﻰ ﺟﻤﻴ ـﻊ اﻟﻤﺘﻐﻴ ـﺮات اﻟﻌﺎﻣ ـﺔ ‪ Public‬واﻟﺴ ـﺘﺎﺗﻴﻜﻴﺔ‬
                                                  ‫ـ‬      ‫ـ‬      ‫ـ‬      ‫ـ‬         ‫ـ‬
‫‪ Static‬اﻟﺨﺎﺻﺔ ﺑﺎﻟﻜﺎﺋﻦ، ﺑﻜﻞ ﺗﺄآﻴﺪ ﻳﺨﺘﻠﻒ ﺣﺠﻤﻬﺎ ﻣﻦ آﺎﺋﻦ ﻵﺧﺮ ﺑﺎﻻﻋﺘﻤﺎد ﻋﻠﻰ ﻋـﺪد‬
                                           ‫071‬


‫وﺣﺠﻢ اﻟﻤﺘﻐﻴﺮات اﻟﺘﺎﺑﻌﺔ ﻟﻪ. ﻓﻤﺜﻼ، اذا اﺣﺘﻮى اﻟﻜﺎﺋﻦ ﻋﻠﻰ ﻣﺘﻐﻴـﺮﻳﻦ ﻣـﻦ ﻧـﻮع ‪،Long‬‬
                                              ‫ﻓﺎن ﺣﺠﻢ هﺬا اﻟﻘﺴﻢ هﻮ 8 ﺑﺎﻳﺖ.‬

                                                              ‫ﻣﺜﺎل ﺗﻮﺿﻴﺤﻲ:‬
‫اود ان اوﺿﺢ اﻻﻗﺴﺎم اﻟﺜﻼﺛﺔ ﺑﻤﺜﺎل ﻣـﻊ ﺷـﻜﻞ ﺗﻮﺿـﻴﺤﻲ ﻟـﻪ. ﺑـﺎﻓﺘﺮاض ان ﻟـﺪﻳﻨﺎ ﻓﺌـﺔ‬
‫ﺑﺎﺳﻢ ‪ MyClass‬ﺗﺤﺘﻮي ﻋﻠـﻰ ﻃـﺮﻳﻘﺘﻴﻦ 1‪ MyMethod‬و 2‪ MyMethod‬ﺑﺎﻻﺿـﺎﻓﺔ اﻟـﻰ‬
                    ‫ﻣﺘﻐﻴﺮﻳﻦ ﻋﺎﻣﻴﻦ ‪ Public‬ﺑﺎﺳﻢ 1‪ Value‬و 2‪ .Value‬ﻓﺎﻟﻜﻮد اﻟﺘﺎﻟﻲ:‬

‫‪Dim X As MyClass, Y As MyClass, Z As MyClass‬‬

‫ﺣﺠﺰ واﻧﺸﺎء ﻧﺴﺦ ﻟﻠﻜﺎﺋﻨﺎت ﻓﻲ اﻟﺬاآﺮة ‘‬
‫‪Set X = New MyClass‬‬
‫‪Set Y = X‬‬
‫‪Set Z = New MyClass‬‬

‫ﺗﺬآﺮ ان آﻼهﻤﺎ ﻣﺆﺷﺮان ﻟﻤﻨﻄﻘﺔ واﺣﺪة ‘‬
‫‪‘ X, Y‬‬
‫”ﺗﺮآﻲ“ = 1‪X.Value‬‬
‫”اﻟﻌﺴﻴﺮي“ = 2‪X.Value‬‬

‫اﺧﻴﺮا ﺗﻌﻴﻴﻦ ﻗﻴﻢ ﻟﻠﻜﺎﺋﻦ ‘‬
‫‪‘Z‬‬
‫”ﻋﺒﺎس“ = 1‪Z.Value‬‬
‫”اﻟﺴﺮﻳﻊ“ = 2‪Z.Value‬‬

                    ‫ﻳﻤﻜﻦ ان ﻧﻮﺿﺢ اﻟﻤﻨﻄﻘﺔ اﻟﺨﺎﺻﺔ ﺑﺎﻟﻜﺎﺋﻨﺎت آﻤﺎ ﻓﻲ اﻟﺸﻜﻞ 5-1:‬
                                                ‫171‬




                      ‫ﺷﻜﻞ 5-1: رﺳﻢ ﺗﻮﺿﻴﺤﻲ ﻟﺼﻮرة اﻟﻜﺎﺋﻨﺎت ‪ Y ،X‬و ‪ Z‬ﺑﺎﻟﺬاآﺮة.‬

‫ﻗﺪ ﻻ ﺗﻬﻤﻚ آﺜﻴـﺮا اﻟﻤﺮﺑﻌـﺎت اﻟﻤﻮﺟـﻮدة ﻓـﻲ اﻟﺸـﻜﻞ 5-1، وﻟﻜـﻦ اﺳـﺘﻴﻌﺎﺑﻬﺎ ﻣﺴـﺄﻟﺔ‬
‫ﺿﺮورﻳﺔ ﻟﺘﻌﺮﻳﻒ ﻓﻜﺮة اﻟﺮﺑﻂ ‪– Binding‬ﻋﻨـﻮان اﻟﻔﻘـﺮة اﻟﺘﺎﻟﻴـﺔ- او ﺣﺘـﻰ اﻻﺣﺘـﺮاف ﻓـﻲ‬
                  ‫ﺑﺮﻣﺠﺔ ﻣﻜﻮﻧﺎت ‪ COM‬وهﻮ ﻣﺎ ﺳﻨﺘﻄﺮق إﻟﻴﻪ ﻓﻲ اﻟﻔﺼﻮل اﻟﻼﺣﻘﺔ.‬

                                                                 ‫اﻟﺮﺑﻂ ‪Binding‬‬
‫ﻋﻤﻠﻴﺔ اﻟﺮﺑﻂ هﻲ ﺑﺎﺧﺘﺼﺎر رﺑﻂ اﻋﻀﺎء ‪ Members‬اﻟﻜﺎﺋﻦ ﺳﻮاء آﺎﻧﺖ ﺧﺼﺎﺋﺺ او ﻃـﺮق‬
  ‫ـ‬             ‫ـ‬      ‫ـ‬        ‫ـ‬
‫ﺑﺎﻟﻤﺆﺷ ـﺮ اﻟ ـﺬي ﻳﻤﺜ ـﻞ اﻟﻜ ـﺎﺋﻦ وﺗﺤﺪﻳ ـﺪ ﻣﻮاﻗ ـﻊ اﻻﺟ ـﺮاءات ﻓ ـﻲ اﻟﺠ ـﺪول ‪ .VTable‬ﻣ ـﻦ‬
                                        ‫ـ‬      ‫ـ‬          ‫ـ‬      ‫ـ‬       ‫ـ ـ‬
‫اﻟﻤﻌﺮوف ان اﻟﻄﺮق ﻣﻮﺟﻮدة ﻓﻲ ﻣﻮاﻗﻊ ﻓﻲ اﻟﺬاآﺮة ﻓﻲ اﻟﺠﺪول ‪ VTable‬ﻟﻜـﻦ ﻋﻤﻠﻴـﺔ‬
                                       ‫اﻟﻮﺻﻮل ﻟﻬﺎ ﻟﻴﺴﺖ ﻣﺒﺎﺷﺮة اﺣﻴﺎﻧﺎ، راﻗﺐ هﻨﺎ:‬

‫‪Dim X As Object‬‬
‫‪If Y = True Then‬‬
   ‫‪Set X = New MyClass‬‬
‫‪Else‬‬
   ‫‪Set X = New YourClass‬‬
‫‪End‬‬
‫‪X.MyMethod‬‬
                                               ‫271‬


‫ﻓﻲ اﻟﺴﻄﺮ اﻻﺧﻴﺮ ﻗﻤﺖ ﺑﺎﺳﺘﺪﻋﺎء اﻟﻄﺮﻳﻘﺔ ‪ MyMethod‬اﻟﺘﺎﺑﻌﺔ ﻟﻠﻜﺎﺋﻦ ‪ ،X‬وﻟﻜﻦ ﻣﺎهﻮ‬
‫اﻟﻜﺎﺋﻦ ‪X‬؟ هﻞ هﻮ ﺗﺎﺑﻊ ﻟﻠﻔﺌﺔ ‪ MyClass‬ام اﻟﻔﺌﺔ ‪YourClass‬؟ ﻻ ﻧﺴﺘﻄﻴﻊ ﻣﻌﺮﻓـﺔ ذﻟـﻚ‬
‫اﻻ ﻓﻲ وﻗـﺖ اﻟﺘﻨﻔﻴـﺬ ﺣﺘـﻰ ﺗﺘﻀـﺢ اﻻﻣـﻮر ﻟــ ‪ ،Visual Basic‬ﻻﻧـﻪ ﻳﺤﺘـﺎج اﻟـﻰ ﻣﻌﺮﻓـﺔ‬
‫ﺗﺮآﻴﺐ اﻟﺠﺪول ‪ VTable‬ﻣﺎ اذا آـﺎن ﻳﻮﺟـﺪ ﺑـﻪ دﻋـﻢ ﻟﻠﻄﺮﻳﻘـﺔ ‪ MyMethod‬او ﻻ،واﻟﺘـﻲ‬
‫ﺑﺪورهﺎ ﺳﺘﺄﺧﺬ وﻗﺖ اﻃﻮل ﺑﻜﺜﻴﺮ ﻣﻦ اﻟﻮﺻﻮل اﻟـﻰ اﺟـﺮاء ﻟﻜـﺎﺋﻦ ﻣﻌـﺮف اﻟﻨـﻮع ﺳـﺎﺑﻘﺎ.‬
                                        ‫ﻟﺬﻟﻚ، اﺗﻜﻠﻢ ﻋﻦ ﻧﻮﻋﻴﻦ ﻣﻦ اﻧﻮاع اﻟﺮﺑﻂ هﻤﺎ:‬

                                                  ‫اﻟﺮﺑﻂ اﻟﻤﺒﻜﺮ ‪:Early Binding‬‬
‫ﻋﻤﻠﻴﺔ اﻟﺮﺑﻂ اﻟﻤﺒﻜـﺮ ﺗـﺘﻢ ﻓـﻲ وﻗـﺖ اﻟﺘﺮﺟﻤـﺔ ‪ Compiling time‬واﻟﺘـﻲ ﺗﻘـﻮم ﺑﺘﺤﺪﻳـﺪ‬
‫ﻣﻮاﺻﻔﺎت اﻟﺘﺮآﻴﺐ ‪ VTable‬ﻣﻤﺎ ﻳﺆدي اﻟﻰ وﺻﻮل اﺳـﺮع ﺑﻜﺜﻴـﺮ ﻻﻋﻀـﺎء اﻟﻜـﺎﺋﻦ. ﻃﺒﻌـﺎ‬
                 ‫ﻟﻌﻤﻞ ذﻟﻚ، ﻻﺑﺪ ﻣﻦ ان ﺗﺤﺪد ﺑﻮﺿﻮح ﻧﻮع اﻟﻔﺌﺔ اﻟﺘﻲ ﺳﻴﻤﺜﻠﻬﺎ اﻟﻜﺎﺋﻦ.‬

‫اﻟﺘﺼﺮﻳﺢ اﻟﻮاﺿﺢ ﻟﻨﻮع اﻟﻜﺎﺋﻨﺎت ‘‬
‫‪Dim X As MyClass, Y As YourClass‬‬

‫‪Set X = New MyClass‬‬

‫ﺑﺎﻓﺘﺮاض وﺟﻮد اﺗﺼﺎل ‘‬
‫‪‘ COM‬‬
‫ﻃﺒﻌﺎ اﺑﻄﺄ ﻟﻜﻦ ﻳﻌﺘﺒﺮ رﺑﻂ ﻣﺒﻜﺮ اﻳﻀﺎ ‘‬
‫)”‪Set Y = CreateObject (“YourServer.YourClass‬‬

                                                    ‫اﻟﺮﺑﻂ اﻟﻤﺘﺄﺧﺮ ‪:Late Binding‬‬
‫هﻨﺎ ﻳﺘﻢ ﺗﺤﺪﻳﺪ ﻣﻮاﺻﻔﺎت اﻟﺘﺮآﻴﺐ ‪ VTable‬ﻓﻲ وﻗﺖ اﻟﺘﻨﻔﻴﺬ ﻓﻲ آﻞ ﻣـﺮة ﺗﺼـﺮح ﻓﻴﻬـﺎ‬
‫ﻋﻦ آﺎﺋﻦ ﺟﺪﻳﺪ، ﻣﻤﺎ ﻳﺆدي اﻟﻰ ﺑﻂء ﻓﻲ ﺗﺤﺪﻳـﺪ اﻟﺠـﺪول ‪ VTable‬اﻟﻤﻨﺎﺳـﺐ ﻟﻠﻜـﺎﺋﻦ،‬
‫واﻟﺘﺤﻘــﻖ ﻣــﻦ وﺟــﻮد اﻟﻄــﺮق اﻟﻤﺴــﺘﺪﻋﺎﻩ. اﻟﻤﺘﻐﻴــﺮات اﻟﻤﻌﺮﻓــﺔ ﻣــﻦ ﻧــﻮع ‪ Object‬او‬
          ‫‪ Variant‬هﻲ ﻣﺘﻐﻴﺮات ﻟﻦ ﺗﺴﺘﻄﻴﻊ ان ﺗﺮﺑﻄﻬﺎ اﻻ ﻋﻦ ﻃﺮﻳﻖ اﻟﺮﺑﻂ اﻟﻤﺘﺄﺧﺮ.‬

‫ﺗﺼﺮﻳﺢ ﻏﻴﺮ واﺿﺢ ﻟﻠﻜﺎﺋﻨﺎت ‘‬
‫‪Dim X As Object, Y As Variant‬‬
‫‪Set X = New MyClass‬‬

‫ﺑﺎﻓﺘﺮاض وﺟﻮد اﺗﺼﺎل ‘‬
‫‪‘ COM‬‬
‫)”‪Set Y = CreateObject (“MyServer.YourClass‬‬
                                           ‫371‬


                                                     ‫وﻻدة وﻣﻮت اﻟﻜﺎﺋﻦ‬
‫وﻻدة اﻟﻜﺎﺋﻦ هﻲ اﻟﻠﺤﻈﺔ اﻟﺘﻲ ﺗﺸﺊ اﻟﻜﺎﺋﻦ ﺑﻬﺎ ﺑﺎﺳﺘﺨﺪام اﻟﻜﻠﻤـﺔ اﻟﻤﺤﺠـﻮزة ‪New‬‬
‫او اﻟﺪوال اﻻﺧﺮى اﻟﺘﻲ ﻟـﻢ اﺗﻄـﺮق ﻟﻬـﺎ ‪ CreateObject‬و ‪ ،GetObject‬وﻳﻤـﻮت اﻟﻜـﺎﺋﻦ‬
‫ﺑﻤﺠﺮد ﺗﺤﺮﻳﺮ اﻟﻤﻨﻄﻘﺔ اﻟﺨﺎﺻﺔ ﺑﻪ ﻓﻲ اﻟﺬاآﺮة آﺨﺮوﺟـﻪ ﻋـﻦ ﻣﺠﺎﻟـﻪ او ﺗﻌﻴـﻴﻦ اﻟﻘﻴﻤـﺔ‬
   ‫‪ Nothing‬ﻟﻪ. اﻋﺮض ﻟﻚ ﺑﻌﺾ اﻟﺘﻔﺎﺻﻴﻞ اﻟﺪﻗﻴﻘﺔ واﻟﺨﺎﺻﺔ ﻋﻦ اﻧﺸﺎء واﻧﻬﺎء اﻟﻜﺎﺋﻦ:‬

                                                   ‫اﻧﺸﺎء اﻟﻜﺎﺋﻦ واﺳﺘﺨﺪاﻣﻪ:‬
‫ﻋﻨﺪﻣﺎ ﺗﻘﻮم ﺑﺎﻧﺸﺎء اﻟﻜﺎﺋﻦ ﻻول ﻣـﺮة ﻳﻘـﻮم ‪ Visual Basic‬ﺑﺤﺠـﺰ ﻣﻨﻄﻘـﺔ ﻓـﻲ اﻟـﺬاآﺮة‬
‫ﺗﻤﺜﻞ اﻟﺘﺮآﻴﺐ ‪ VTable‬ﻟﻠﻔﺌﺔ اﻟﺘﻲ ﺗﻤﺜﻞ ذﻟﻚ اﻟﻜـﺎﺋﻦ. ﺑﻌـﺪ ذﻟـﻚ، ﻳﻘـﻮم ‪Visual Basic‬‬
‫ﺑﺤﺠﺰ ﻣﻨﻄﻘﺔ اﺧﺮى ﺑﺎﻟﺬاآﺮة ﺧﺎﺻﺔ ﺑﻤﻨﻄﻘﺔ ﻧﺴـﺨﺔ اﻟﺒﻴﺎﻧـﺎت ‪Instancing Data Area‬‬
‫واﻟﺘﻲ ﻳﻘﻮم ﺑﺘﻘﺴﻴﻤﻬﺎ اﻟﻰ ﺛﻼﺛﺔ اﻗﺴـﺎم وﻣـﻦ ﺛـﻢ ﺗﻌﺒﺌـﺔ اﻟﻤﻌﻠﻮﻣـﺎت اﻟﻤﻄﻠﻮﺑـﺔ ﻓـﻲ‬
‫ﻣﻜﺎﻧﻬﺎ اﻟﻤﻨﺎﺳﺐ ﻓﻲ آﻞ ﻗﺴﻢ. اﻟﻘﺴﻢ اﻻول ﻟﻮﺿﻊ ﻋﻨﻮان ‪ VTable‬ﻟﻠﻤﺆﺷﺮ ‪VTable‬‬
‫واﻟﺜﺎﻧﻲ ﻳﺒﺪأ ﻋﺪادﻩ. وﻻ ﻳﺒﺪأ ﻓﻲ اﻟﻘﺴﻢ اﻻﺧﻴﺮ اﻻ ﺑﻌﺪ ﺗﻔﺠﻴﺮ اﻟﺤﺪث ‪Class_Initialize‬‬
                 ‫ﻻن ذﻟﻚ اﻻﺟﺮاء اﺻﺒﺢ ﻋﻨﻮاﻧﻪ ﻣﻌﺮوف ﺑﻔﻀﻞ ﺗﻌﺮﻳﻒ اﻟﻤﺆﺷﺮ ‪.VTable‬‬
‫اﻣﺎ ﻓﻲ ﺣﺎﻟﺔ اﻧﺸﺎء آﺎﺋﻦ ﻣﺮة اﺧﺮى، ﻓﺎن اﻟﻌﻤﻠﻴﺔ ﺗﺘﻢ ﺑﺸﻜﻞ اﺳﺮع وذﻟﻚ ﺑﺴـﺒﺐ ان‬
‫‪ Visual Basic‬ﻻ ﻳﻘـﻮم ﺑﺤﺠـﺰ اﻟﻤﻨﻄﻘـﺔ ﺑﺎﻟـﺬاآﺮة واﻟﺨﺎﺻـﺔ ﺑــ ‪ VTable‬ﻓﻬـﻲ ﻣﻮﺟـﻮدة‬
‫وﺟﺎهﺰة ﻻي آـﺎﺋﻦ ﺟﺪﻳـﺪ ﺳﻴﻨﺸـﺄ ﻣـﻦ ﻧﻔـﺲ ﻧـﻮع اﻟﻔﺌـﺔ اﻟﺴـﺎﺑﻖ. اﺧﻴـﺮا، ﺗﺴـﺘﻄﻴﻊ‬
            ‫اﺳﺘﺨﺪام اﻟﻜﺎﺋﻦ واﺳﺘﺪﻋﺎء ﻃﺮﻗﻪ و ﺗﻌﻴﻴﻦ ﺧﺼﺎﺋﺼﻪ وﺣﺘﻰ اﻧﺘﻈﺎر اﺣﺪاﺛﻪ.‬

                                                   ‫ﻧﻬﺎﻳﺔ وﺟﻮد اﻟﻜﺎﺋﻦ ﺑﺎﻟﺬاآﺮة:‬
‫ﻋﻨﺪﻣﺎ ﻳﺼﻞ اﻟﻌﺪاد اﻟﻰ ﺻﻔﺮ ﺳﻴﻘﻮم ‪ Visual Basic‬ﺑﺘﻔﺠﻴﺮ اﻟﺤﺪث ‪Class_Terminate‬‬
‫واﻟﺨﺎص ﺑﺎﻟﻜﺎﺋﻦ ﻣﺘﻴﺤﺎ ﻟﻚ ﻓﺮﺻﺔ اﺧﻴـﺮة ﻟﻌﻤـﻞ أي ﺷـﺊ ﻗﺒـﻞ ﻣـﻮت اﻟﻜـﺎﺋﻦ وﻣـﻦ ﺛـﻢ‬
‫ﻳﻘﻮم ﺑﺘﺤﺮﻳﺮ ﻣﻨﻄﻘﺔ ﻧﺴﺨﺔ اﻟﺒﻴﺎﻧﺎت ‪ Instancing Data Area‬ﻣﻦ اﻟﺬاآﺮة وﻓﻘﻂ، أي ﻻ‬
‫ﺗﺘﻮﻗﻊ ان ﻳﻘﻮم ‪ Visual Basic‬ﺑﺘﺤﺮﻳﺮ ﻣﻨﻄﻘﺔ اﻟﺘﺮآﻴـﺐ ‪ VTable‬ﻻﻧﻬـﺎ ﺳـﺘﻜﻮن ﺑﺎﻟـﺬاآﺮة‬
‫ﺣﺘﻰ ﻧﻬﺎﻳﺔ اﻟﺒﺮﻧﺎﻣﺞ ﺑﻌﺒﺎرة ‪ End‬واﻋﺘﻘﺪ ان هﺬا ﺳﺒﺐ واﺿﺢ ﻓﻲ آـﻮن ﻋﻤﻠﻴـﺔ اﻧﺸـﺎء‬
‫اﻟﻜﺎﺋﻦ ﻣﺮة اﺧﺮى اﺳﺮع ﺑﻜﺜﻴﺮ ﻣﻦ اﻟﻤﺮة اﻻوﻟﻰ ﺑﺴﺒﺐ ﻋﺪم ﺿﺮورة اﻧﺸﺎء اﻟـ ‪VTable‬‬
                                                                      ‫ﻣﻦ ﺟﺪﻳﺪ.‬
‫ﻟﺪي ﻧﻘﻄﺔ اﺧﺮى ﺣﻮل اﻟﺤﺪث ‪ .Class_Terminate‬ﻓﻔﻲ هﺬا اﻟﺤﺪث ﺗﺴﺘﻄﻴﻊ ﻓﻌﻞ ﻣﺎ‬
‫ﺗﺮﻳﺪ ﻗﺒﻞ ﻣﻮت اﻟﻜﺎﺋﻦ ﻟﻜﻦ ﻣﻦ اﻟﻤﻬﻢ ﻣﻌﺮﻓﺔ اﻧﻚ ﻟﻦ ﺗﺴﺘﻄﻴﻊ اﻋﺎدة ﺣﻴﺎة اﻟﻜـﺎﺋﻦ ﻋـﻦ‬
‫ﻃﺮﻳﻖ هﺬا اﻟﺤﺪث. اﻟﻔﻜﺮة ﺑﺒﺴﺎﻃﺔ هﻲ آﺎﻻﻧﺴﺎن ﻋﻨﺪﻣﺎ ﻳﺤﺘﻀﺮ، ﻓﺎن ﻣﻦ رﺣﻤـﻪ اﷲ‬
‫ﻳﻴﺴﺮ ﻟﻪ اﻟﺸﻬﺎدة وﻗﺖ اﻻﺣﺘﻀﺎر وﻳﻨﻄﻖ ﺑﻬﺎ وﻣﻦ ﺛﻢ ﻳﻤﻮت ﻟﻜﻨﻪ ﻟﻦ ﻳﺴـﺘﻄﻴﻊ اﻟﻌـﻮدة‬
‫اﻟﻰ اﻟﺤﻴﺎة ﻣﻦ ﺟﺪﻳﺪ -اﻻ ﺑﻤﻌﺠﺰة اﻟﺨـﺎﻟﻖ اﻟـﺬي ﻳﺤﻴـﻲ وﻳﻤﻴـﺖ ﺑﻜـﻞ ﺗﺄآﻴـﺪ- اﻣـﺎ ﻣـﻊ‬
‫‪ Visual Basic‬ﻓﻴﻮﻓﺮ ﻟﻚ اﻟﺤﺪث ‪ Class_Terminate‬ﻓﺮﺻﺔ اﺧﻴﺮة ﻟﻌﻤﻞ ﻣﺎ ﺗﺮﻳﺪ ﻗﺒـﻞ ان‬
                            ‫ﻳﻤﻮت اﻟﻜﺎﺋﻦ ﻟﻜﻨﻚ ﻟﻦ ﺗﺴﺘﻄﻴﻊ اﻋﻄﺎﺋﻪ اﻟﺤﻴﺎة ﻣﻦ ﺟﺪﻳﺪ.‬
                                              ‫471‬


‫ﻧﻘﻄﺔ اﺧﺮى ﺣﻮل ﻣﻮت اﻟﻜﺎﺋﻨﺎت -ﻧﺴﺄل اﷲ ﻃﻮﻟﺔ اﻟﻌﻤﺮ- هـﻲ ان اﻟﻜﺎﺋﻨـﺎت ﻟﻬـﺎ ﻧﻈـﺎم‬
‫ﻳﻤﻨﻊ ﻣﻮت اﻟﻜﺎﺋﻦ اذا ﻣﺎ آﺎن اﺣﺪ اﺟﺮاءاﺗﻪ ﻗﻴﺪ اﻟﺘﻨﻔﻴﺬ. وﺑﻤﻌﻨﻰ ﺁﺧﺮ، ﻟﻨﻔﺘـﺮض ان اﺣـﺪ‬
‫اﺟﺮاءات اﻟﻜﺎﺋﻦ ﻳﻘـﻮم ﺑﻘﺘـﻞ ﻧﻔﺴـﻪ ‪) Set X = Nothing‬اآﻴـﺪ اﻟﻤﺘﻐﻴـﺮ ‪ X‬ﻣﺆﺷـﺮ ﻋـﺎم(‬
‫ﻓﻼﺑﺪ ان ﺗﻌﻠﻢ ان ‪ Visual Basic‬راﻗﻲ ﺟﺪا ﺟﺪا وﻳﻌﻠﻢ آﻴﻒ ﻳﺘﻌﺎﻣﻞ ﻣﻊ هﺬﻩ اﻟﻨﻮع ﻣـﻦ‬
‫اﻟﻜﺎﺋﻨﺎت!، ﻓﺴﻴﻘﻮم ﺑﺎﺳﻠﻮب ﻣﻬﺬب ﺟﺪا اﻋﻄﺎء ﻓﺮﺻﺔ ﻟﻠﻜﺎﺋﻦ ﺣﺘﻰ ﻳﻨﻬﻲ اﺟﺮاءﻩ اﻟﺬي‬
‫ﻳﺘﻢ ﺗﻨﻔﻴﺬﻩ وﻣﻦ ﺛﻢ ﻳﻘﻮم ﺑﺘﻔﺠﻴﺮ اﻟﺤﺪث ‪ Class_Terminate‬وﻗﺘﻞ اﻟﻜﺎﺋﻦ. اﺣﺴـﻦ اﷲ‬
                                                                          ‫ﻋﺰاآﻢ.‬

                                     ‫ارﺳﺎل اﻟﻜﺎﺋﻦ ﺑﺎﻟﻤﺮﺟﻊ او ﺑﺎﻟﻘﻴﻤﺔ‬
‫ﺗﺤﺪﺛﺖ ﻓﻲ اﻟﻔﺼـﻞ اﻟﺜﺎﻟـﺚ "ﻟﻐـﺔ اﻟﺒﺮﻣﺠـﺔ ‪ "BASIC‬وﺑﺎﻟﺘﺤﺪﻳـﺪ ﻓـﻲ ﻗﺴـﻢ اﻻﺟـﺮاءات‬
‫واﻟﺪوال ﻋﻦ اﻟﻔﺮق ﺑﻴﻦ ارﺳﺎل ﻣﺮﺟﻊ اﻟﻤﺘﻐﻴﺮ اﻟﻰ اﻻﺟﺮاء وارﺳﺎل ﻗﻴﻤـﺔ اﻟﻤﺘﻐﻴـﺮ اﻟـﻰ‬
‫اﻻﺟﺮاء، وذآﺮت ﺑﺎن اﻟﻤﺘﻐﻴﺮات اﻟﻤﺮﺳﻠﺔ ﺑﺎﻟﻤﺮﺟﻊ ﻳﻤﻜﻦ ﻟـﻚ اﻟﺘﻌـﺪﻳﻞ ﻓـﻲ ﻗﻴﻤﻬـﺎ ﻣـﻦ‬
‫ﻧﻔﺲ اﻻﺟﺮاء، وﻟﻜﻦ ﻋﻨﺪ اﻟﺤﺪﻳﺚ ﻋﻦ اﻟﻜﺎﺋﻨـﺎت ﻓﺤـﺎول ﻧﺴـﻴﺎن اﻟﻔـﺮق ﺑـﻴﻦ اﻻرﺳـﺎل‬
‫ﺑــﺎﻟﻤﺮﺟﻊ واﻟﻘﻴﻤــﺔ، ﻻن اﻟﻜــﺎﺋﻦ ﻓــﻲ آــﻼ اﻟﺤــﺎﻟﻴﻦ ﺳﻴﺮﺳــﻞ ﻣﺆﺷــﺮ ‪ Pointer‬اﻟﻜــﺎﺋﻦ‬
                                ‫وﺳﻴﺘﻤﻜﻦ اﻻﺟﺮاء ﻣﻦ ﺗﻌﺪﻳﻞ ﺟﻤﻴﻊ ﻣﺤﺘﻮﻳﺎت اﻟﻜﺎﺋﻦ.‬
‫اﻣﺎ اﻟﻔﺮق ﺑـﻴﻦ اﺳـﺘﺨﺪام اﻟﻜﻠﻤـﺔ اﻟﻤﺤﺠـﻮزة ‪ ByVal‬واﻟﻜﻠﻤـﺔ اﻟﻤﺤﺠـﻮزة ‪ ByRef‬ﻓﻬـﻮ‬
‫ﻓﺮق ﺗﻘﻨﻲ ﺑﺤﺖ، اذ ان ارﺳﺎل اﻟﻜـﺎﺋﻦ ﺑﺎﻟﻜﻠﻤـﺔ اﻟﻤﺤﺠـﻮزة ‪ ByVal‬ﻳـﺆدي اﻟـﻰ اﻧﺸـﺎء‬
‫ﻧﺴﺨﺔ ﺟﺪﻳﺪة ﻣﻦ اﻟﻤﺆﺷﺮ ﺗﺆدي اﻟـﻰ زﻳـﺎدة اﻟﻌـﺪاد ‪ Counter‬اﻟﺘـﺎﺑﻊ ﻟﻤﻨﻄﻘـﺔ ﺑﻴﺎﻧـﺎت‬
‫اﻟﻜﺎﺋﻦ، اﻣﺎ اﻻرﺳﺎل ﺑﺎﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ ByRef‬ﻓﺎن اﻟﻤﺆﺷﺮ هﻮ ﻧﻔـﺲ اﻟﻤﺆﺷـﺮ اﻟـﺬي‬
                                     ‫ارﺳﻞ اﻟﻰ اﻻﺟﺮاء، هﺬا اﻟﻜﻮد ﻗﺪ ﻳﻮﺿﺢ اﻟﻔﺮق:‬

‫اﻻرﺳﺎل ﺑﺎﻟﻤﺮﺟﻊ ‘ ) ‪Sub MySub ( objPerson As Person‬‬

       ‫‪Set objPerson = Nothing‬‬        ‫ﺗﺆدي اﻟﻰ ﻣﻮت اﻟﻜﺎﺋﻦ اﻟﻤﺮﺳﻞ ‘‬

‫‪End Sub‬‬

‫) ‪Sub MySub ( ByVal objPerson As Person‬‬      ‫اﻻرﺳﺎل ﺑﺎﻟﻘﻴﻤﺔ ‘‬

       ‫‪Set objPerson = Nothing‬‬        ‫ﻻ ﺗﺆدي اﻟﻰ ﻣﻮت اﻟﻜﺎﺋﻦ اﻟﻤﺮﺳﻞ ‘‬

‫‪End Sub‬‬
                                             ‫571‬


                                    ‫اﻟﻔﺼﻞ اﻟﺴﺎدس‬
                    ‫ﺗﻌﺪد اﻟﻮاﺟﻬﺎت واﻟﻮراﺛﺔ‬


‫ﺗﺤﺪﺛﺖ ﻓﻲ اﻟﻔﺼـﻞ اﻟﺴـﺎﺑﻖ ﻋـﻦ اﻟﻔﺌـﺎت واﻟﻜﺎﺋﻨـﺎت، وذآـﺮت اﻧـﻪ آﻠﻤـﺎ آﺎﻧـﺖ اﻟﻔﺌـﺔ‬
‫ﻣﺴﺘﻘﻠﺔ آﻠﻤـﺎ زادت اﻣﻜﺎﻧﻴـﺔ اﻋـﺎدة اﺳـﺘﺨﺪاﻣﻬﺎ ﻓـﻲ ﺗﻄﺒﻴﻘـﺎت اﺧـﺮى، اﻻ اﻧـﻚ ﻓـﻲ‬
‫ﺣﺎﻻت آﺜﻴﺮة ﺗﻮد ﺗﻮزﻳﻊ اﻻآﻮاد ﺑﻴﻦ ﻋﺪة ﻓﺌﺎت وﺗﺤﺎول ﺗﻄﺒﻴﻖ رواﺑﻂ ﺑـﻴﻦ اﻟﻔﺌـﺎت ﻟﺘـﻮﻓﺮ‬
‫ﻋﻠﻴﻚ ﻋﻨﺎء اﻋﺎدة آﺘﺎﺑﺔ اﻻآﻮاد اﻟﻤﺘﻜﺮرة وﺗﺴﻬﻴﻞ ﺣﻴﺎﺗﻚ اﻟﺒﺮﻣﺠﻴﺔ ﺑﺸﻜﻞ اﻓﻀﻞ. ﻓـﻲ‬
‫هﺬا اﻟﻔﺼﻞ ﺳﺄﺗﻄﺮق اﻟﻰ ﻣﻮاﺿﻴﻊ ﻣﺘﻘﺪﻣﺔ ﻓﻲ اﻟﺒﺮﻣﺠﺔ آﺎﺋﻨﻴﺔ اﻟﺘﻮﺟـﻪ واﺗﺤـﺪث ﻋـﻦ‬
 ‫ﻣﺒﺪأ ﺗﻌﺪد اﻟﻮاﺟﻬﺎت وﻣﺒﺪأ اﻟﻮراﺛﺔ، واﺧﺘﻢ اﻟﻔﺼﻞ ﺑﺎﻟﺘﺤﺪث ﻋﻦ ﻓﻜﺮة اﻻهﺮام اﻟﻜﺎﺋﻨﻴﺔ.‬


                                                                    ‫ﺗﻌﺪد اﻟﻮاﺟﻬﺎت‬
‫ﻣﺒﺪأ ﺗﻌﺪد اﻟﻮاﺟﻬﺎت ‪ Polymorphism‬ﻣﻦ اﻟﻤﺒﺎدئ اﻟﺘﻲ ﻻﺑﺪ ﻣﻦ ﺗﻮﻓﺮهـﺎ ﻓـﻲ أي ﻟﻐـﺔ‬
‫ﺑﺮﻣﺠﺔ آﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ ‪ .OOP‬وﻣﻦ ﺣﺴﻦ اﻟﺤﻆ ‪ Visual Basic‬ﻳﺪﻋﻢ اﻟﻔﻜﺮة اﻻﺳﺎﺳـﻴﺔ‬
‫ﻣﻦ هﺬا اﻟﻤﺒﺪأ، ﺳﺄﺷﺮح ﻓﻲ هﺬﻩ اﻟﻔﻘـﺮة ﻃﺮﻳﻘـﺔ ﺗﻄﺒﻴـﻖ ﻣﺒـﺪأ ﺗﻌـﺪد اﻟﻮﺟﻬـﺎت آﻤـﺎ‬
                                        ‫اﺗﻄﺮق اﻟﻰ اﻟﻔﺌﺎت اﻟﻤﺠﺮدة ‪.Abstract Classes‬‬
‫اﻟﺘﻌﺮﻳﻒ اﻟﺒﺮﻣﺠﻲ ﻟﻤﺒﺪأ ﺗﻌﺪد اﻟﻮاﺟﻬﺎت هﻮ: اﺳﻤﺎء ﻣﺘﺸـﺎﺑﻬﺔ ﻟﻜـﻦ اﻧﺠـﺎزات ﻣﺨﺘﻠﻔـﺔ‬
‫‪ .Same names but different implementations‬اﻟﻤﻘﺼـﺪ ﻣـﻦ ذﻟـﻚ، اﻧﻨـﺎ ﻧﺴـﺘﻄﻴﻊ‬
‫اﺳــﺘﺪﻋﺎء ﻃــﺮق وﺧﺼــﺎﺋﺺ ﻣﺘﺸــﺎﺑﻬﺔ اﻻﺳــﻢ ﻟﻔﺌــﺎت ﻣﺨﺘﻠﻔــﺔ اﻟﺒﻨﻴــﺎن أي ﺑﺎﻧﺠــﺎزات‬
‫ﻣﺨﺘﻠﻔﺔ. ﻣﺜﺎل، ﻧﻔﺘﺮض ان ﻟﺪﻳﻨﺎ ﻓﺌﺘﻴﻦ اﻻوﻟـﻰ ‪ CPerson‬واﻟﺜﺎﻧﻴـﺔ ‪ ،CCar‬آـﻼ اﻟﻔﺌﺘـﻴﻦ‬
                           ‫ـ‬                               ‫ـ‬                  ‫ـ‬
‫ﻳﻮﺟ ـﺪ ﺑﻬﻤــﺎ ﻃﺮﻳﻘــﺔ ﺧﺎﺻ ـﺔ ﺑﺎﻟﺘﺤﺮﻳــﻚ ﺗﺴــﻤﻰ ‪ ،Move‬وﺑﺎﻟﺘ ـﺎﻟﻲ ﻧﺴــﺘﻄﻴﻊ اﺳــﺘﺪﻋﺎء‬
‫اﻟﻄﺮﻳﻘﺘﻴﻦ ﺑﺎﺳﻤﺎﺋﻬﻤﺎ: ‪ CPerson.Move‬و ‪ .CCar.Move‬ﻟﻜـﻦ اﻟﻘﻀـﻴﺔ هﻨـﺎ ان ﻋﻤﻠﻴـﺔ‬
‫اﻧﺠﺎز اﻟﻄﺮﻳﻘﺔ ﻣﺨﺘﻠﻔﺔ رﻏﻢ ﺗﺸﺎﺑﻪ اﺳﻤﺎﺋﻬﺎ، ﻓﻤﻦ اﻟﻤﻌﺮوف ان اﻟﺸـﺨﺺ ﻳﺘﺤـﺮك ﻋـﻦ‬
‫ﻃﺮﻳﻖ ﻗﺪﻣﻴﻪ اﻣﺎ اﻟﺴﻴﺎرة ﻓﺒﻼ ﺷﻚ ﺗﺘﺤﺮك ﻋﻦ ﻃﺮﻳﻖ اﻻرﺑـﻊ ﻋﺠـﻼت ﺑﻬـﺎ، وهـﺬا هـﻮ‬
                                                                ‫ﻣﺒﺪأ ﺗﻌﺪد اﻟﻮﺟﻬﺎت.‬
‫اﻟﻤﺰاﻳﺎ اﻟﺘﻲ ﺗﺠﺪهﺎ ﻣﻦ ﺗﻌﺪد اﻟﻮاﺟﻬﺎت آﺜﻴﺮة وﻟﻌﻞ اﻟﻤﻴﺰة اﻟﺤﻘﻴﻘﻴﺔ هﻲ اﻧﻬـﺎ ﺗﺨﺘﺼـﺮ‬
‫ﻋﻠﻴﻚ اﻟﻜﺜﻴﺮ ﻣﻦ ﻣﺌﺎت ﺟﻤـﻞ اﻟﺸـﺮط آــ ‪ Select Case‬وﻏﻴﺮهـﺎ. ﻓﻘـﺪ ﺗﻼﺣـﻆ ان ﻣﺒـﺪأ‬
‫ﺗﻌﺪد اﻟﻮاﺟﻬﺎت ﻣﻄﺒﻖ ﻓﻲ اﻻدوات اﻟﺘـﻲ ﺗﻀـﻌﻬﺎ ﻋﻠـﻰ ﻧﺎﻓـﺬة اﻟﻨﻤـﻮذج وذﻟـﻚ ﺑﺴـﺒﺐ‬
‫وﺟﻮد اﻟﻜﺜﻴﺮ ﻣﻦ اﻟﺨﺼﺎﺋﺺ اﻟﻤﺸـﺘﺮآﺔ ﺑـﻴﻦ اﻻدوات آﺨﺎﺻـﻴﺔ ‪ Left‬او ‪ Name‬وﻏﻴﺮهـﺎ،‬
                                              ‫671‬


‫ﻓﻠﻮ ﻃﻠﺒﺖ ﻣﻨﻚ اﺣﺪ اﻻﻳﺎم آﺘﺎﺑﺔ اﺟﺮاء ﻳﻘﻮم ﺑﻤﺤﺎذاة اداة اﻟـﻨﺺ ‪ TextBox‬ﻓـﻲ وﺳـﻂ‬
                        ‫اﻟﻨﺎﻓﺬة، ﻓﺴﺘﻜﻮن ﺣﺼﻴﻠﺔ اﺻﺎﺑﻌﻚ اﻟﻨﺎﻋﻤﺔ اﻟﻜﻮد اﻟﺘﺎﻟﻲ:‬

‫) ‪CenterTextBox ( txtTextBox As TextBox‬‬
‫_ ,2 / )‪txtTextBox.Move ScaleWidth - txtTextBox.Width‬‬
             ‫2 / )‪ScaleHeight - txtTextBox.Height‬‬
‫‪End Sub‬‬

‫وﻟﻮ آﺎﻧﺖ ﻋﻼﻗﺘﻨﺎ ﺣﻤﻴﻤـﺔ ﺟـﺪا وﻃﻠﺒـﺖ ﻣﻨـﻚ اﺟـﺮاء ﺁﺧـﺮ ﻳﻘـﻮم ﺑﻤﺤـﺎذاة اداة اﻟﻌﻨـﻮان‬
                                          ‫‪ ،Label‬ﻓﺎﻋﺘﻘﺪ اﻧﻚ ﺳﺘﻜﺘﺐ اﻻﺟﺮاء اﻟﺘﺎﻟﻲ:‬

‫)‪CenterLabel ( lblLabel As Label‬‬
‫_ ,2 / )‪lblLabel.Move ScaleWidth - lblLabel.Width‬‬
               ‫2 / )‪ScaleHeight - lblLabel.Height‬‬
‫‪End Sub‬‬

‫وﻻ اﻋﺘﻘﺪ اﻧﻚ ﻋﻠﻰ اﺳـﺘﻌﺪاد ﻟﻜﺘﺎﺑـﺔ 81 اﺟـﺮاء اﺧـﺮ ﻟﺘﻮﺳـﻴﻂ اﻻدوات اﻟﺜﻤﺎﻧﻴـﺔ ﻋﺸـﺮ‬
‫اﻻﺧﺮى ﺣﺘﻰ ﻟﻮ آﺎﻧﺖ ﻋﻼﻗﺘﻨﺎ ﻋﺎﻃﻔﻴﺔ! ﺑﻞ ﺳﺘﻜﻮن ﻣﺒﺮﻣﺞ آﺎﺋﻨﻲ اﻟﺘﻮﺟﻪ اآﺜﺮ وﺗﻜﺘـﺐ‬
                           ‫اﺟﺮاء واﺣﺪ ﻳﻤﻜﻦ ان ﻳﺴﺘﻘﺒﻞ أي اداة ﻣﻬﻤﺎ آﺎن ﻧﻮﻋﻬﺎ:‬

‫) ‪CenterControl ( ctrlControl As Control‬‬
‫_ ,2 / )‪ctrlControl.Move ScaleWidth - ctrlControl.Width‬‬
               ‫2 / )‪ScaleHeight - ctrlControl.Height‬‬
‫‪End Sub‬‬

‫ﻣﻦ اﻻﺟﺮاء اﻟﺴـﺎﺑﻖ ﻳﺘﻀـﺢ ﻟﻨـﺎ ﺟﻤـﺎل، ﻗـﻮة، اﺑـﺪاع، ﻣﺮوﻧـﺔ، ﻓـﻦ، وﺳـﺤﺮ ﻣﺒـﺪأ ﺗﻌـﺪد‬
‫اﻟﻮاﺟﻬﺎت ﻓﺎﻟﻔﺌﺔ ‪ TextBox‬ﻟﻬﺎ واﺟﻬـﺔ اﺧـﺮى ﺑﺎﺳـﻢ ‪ Control‬ﺗﺤﺘـﻮي ﻋﻠـﻰ اﻟﻄﺮﻳﻘـﺔ‬
‫‪ Move‬ﺣﺎﻟﻬﺎ آﺤﺎل ﺟﻤﻴﻊ اﻻدوات اﻻﺧﺮى. اﻟﻮاﺟﻬﺔ ‪ Control‬هﻲ ﻋﺒﺎرة ﻋﻦ ﻓﺌﺔ ﻟﻜﻨﻬﺎ‬
                             ‫ـ‬               ‫ـ‬                 ‫ـ‬
‫ﻻ ﺗﺤﺘـﻮي ﻋﻠـﻰ اﻳـﺔ اآـﻮاد، ﻟـﺬﻟﻚ ﺗﺴـﻤﻰ ﻓﺌـﺔ اﻟﻤﺠـﺮدة ‪Abstract Class Control‬‬
‫وﺗﺤﺘﻮي ﻋﻠﻰ واﺟﻬﺔ ‪ ،Interface‬ﻓﺤﺘﻰ ﺗﺴﺘﻄﻴﻊ ان ﺗﺤﻘﻖ ﻣﺒﺪأ ﺗﻌﺪد اﻟﻮﺟﻬـﺎت ﻻﺑـﺪ‬
                    ‫ﻣﻦ وﺟﻮد ﻓﺌﺔ ﻣﺠﺮدة واﻟﺘﻲ ﺗﻌﺮف اﻟﻮاﺟﻬﺔ ﻟﻠﻔﺌﺎت اﻻﺧﺮى ﻣﻨﻬﺎ.‬

                                                             ‫ﺗﻄﺒﻴﻖ ﻋﻤﻠﻲ:‬
‫واﻻن ﻟﻨﺒﺪأ ﺑﺎﻟﺘﻄﺒﻴﻖ، ﺳﻨﻨﺸﺊ ﻓﺌﺔ ﻣﺠﺮدة )واﺟﻬﺔ( ﺑﺎﺳﻢ ‪ ITrip‬واﻟﺘﻲ ﺗﻤﺜـﻞ رﺣﻠـﺔ‬
                                           ‫وﺗﻌﺮﻳﻒ ﻃﺮﻳﻘﺔ ﺑﻬﺎ ﻟﻤﻌﺮﻓﺔ اﻟﺘﻜﺎﻟﻴﻒ:‬
                                             ‫771‬



‫‪Function GetCost(iDistance As Integer) As Integer‬‬
‫ﻻ ﺗﻜﺘﺐ ﺷﻴﺌﺎ هﻨﺎ ﻓﻬﺬﻩ ﻣﺠﺮد واﺟﻬﻪ ‘‬
‫‪End Function‬‬

 ‫ﺟﺮى اﻟﻌﺮف ﻋﻨﺪ ﻣﺒﺮﻣﺠﻲ ‪ OOP‬ﺑﺘﻤﻴﻴﺰ اﻟﻮاﺟﻬﺔ ﻋﻦ اﻟﻔﺌﺔ ﻋﻦ ﻃﺮﻳـﻖ‬             ‫ﻣﻼﺣﻈﺔ:‬
    ‫ـ‬                                ‫ـ‬
 ‫اﺿـﺎﻓﺔ ﺣـﺮف اﻟﺒﺎدﺋـﺔ ‪ I‬ﻗﺒـﻞ اﺳـﻢ اﻟﻔﺌـﺔ، اﻣـﺎ اﻟﻔﺌـﺎت ﻓﻤـﺎ زال ﺣـﺮف‬
                                         ‫اﻟﺒﺎدﺋﺔ ‪ C‬هﻮ اﻻآﺜﺮ ﺷﻌﺒﻴﺔ.‬

   ‫واﻻن اﻧﺸﺎء ﻓﺌﺔ اﺧﺮى وهﻲ ﺗﻤﺜﻞ رﺣﻠﺔ ﺑﺎﻟﺴﻴﺎرة ﻻ ﺗﻨﺴﻰ ان ﺗﺴﻤﻴﻬﺎ ﺑـ ‪:CCar‬‬

‫ﻻ ﺑﺪ ان ﺗﻀﻴﻒ هﺬﻩ اﻟﻌﺒﺎرة ﺣﺘﻰ ‘‬
‫ﻧﺴﺘﺨﺪم اﻟﻮاﺟﻬﺔ اﻟﺘﺎﺑﻌﺔ ﻟﻔﺌﺔ ‘‬
‫‪‘ ITrip‬‬
‫‪Implements ITrip‬‬

‫‪Private Function ITrip_GetCost(iDistance As Integer) As Integer‬‬
‫هﺬﻩ اﻟﺪاﻟﺔ ﻣﺄﺧﻮذة ﻣﻦ واﺟﻬﺔ ‘‬
‫‪‘ ITrip‬‬
   ‫51 * ‪ITrip_GetCost = iDistance‬‬
‫‪End Function‬‬

 ‫ﻻ ﻳﻮﺟﺪ داﻋـﻲ ﻣـﻦ آﺘﺎﺑـﺔ اﻻﺟـﺮاء اﻟﺴـﺎﺑﻖ ﺑﻨﻔﺴـﻚ، ﻓﺒﻤﺠـﺮد آﺘﺎﺑـﺔ‬        ‫ﻣﻼﺣﻈﺔ:‬
 ‫اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ Implements‬ﺑﺎﻣﻜﺎﻧﻚ اﻟﻮﺻﻮل اﻟـﻰ آﺎﻓـﺔ اﺟـﺮاءات‬
    ‫ـ‬            ‫ـ‬                              ‫ـ‬
 ‫اﻟﻮاﺟﻬـﺔ ﻋـﻦ ﻃﺮﻳـﻖ اﻻداة ‪ ComboBox‬اﻟﻤﻮﺟـﻮدة ﻓـﻲ اﻋﻠـﻰ ﻧﺎﻓـﺬة‬
                                                    ‫ﻣﺤﺮر اﻻآﻮاد.‬

                                       ‫اﻳﻀﺎ ﻓﺌﺔ اﺧﺮى ﺗﻤﺜﻞ رﺣﻠﺔ ﺑﺎﻟﻄﺎﺋﺮة ‪:CPlane‬‬

‫ﻻ ﺑﺪ ان ﺗﻀﻴﻒ هﺬﻩ اﻟﻌﺒﺎرة ﺣﺘﻰ ‘‬
‫ﻧﺴﺘﺨﺪم اﻟﻮاﺟﻬﺔ اﻟﺘﺎﺑﻌﺔ ﻟﻔﺌﺔ ‘‬
‫‪‘ ITrip‬‬
‫‪Implements ITrip‬‬

‫‪Private Function ITrip_GetCost(iDistance As Integer) As Integer‬‬
‫هﺬﻩ اﻟﺪاﻟﺔ ﻣﺄﺧﻮذة ﻣﻦ واﺟﻬﺔ ‘‬
                                              ‫871‬


‫‪‘ ITrip‬‬
   ‫ﻻﺣﻆ زﻳﺎدة ﺳﻌﺮ اﻟﺘﻜﻠﻔﺔ هﻨﺎ ‘ 001 * ‪ITrip_GetCost = iDistance‬‬
‫‪End Function‬‬

‫اﻧﺘﻬﻴﻨﺎ ﻣﻦ ﺗﺼﻤﻴﻢ اﻟﻮاﺟﻬﺔ ‪ ITrip‬واﻟﻔﺌﺎت ‪ CCar‬و ‪ ،CPlane‬وﻻﺳﺘﺨﺪاﻣﻬﺎ اﻧﺘﻘـﻞ اﻟـﻰ‬
                            ‫ﻧﺎﻓﺬة اﻟﻨﻤﻮذج ﺛﻢ ﺿﻊ اداة زر اواﻣﺮ واآﺘﺐ هﺬا اﻟﻜﻮد:‬

‫)(‪Private Sub Command1_Click‬‬
‫‪Dim NewTrip As ITrip‬‬

  ‫اﻟﺮﺣﻠﺔ اﻻن ﺑﺎﻟﺴﻴﺎرة ‘ ‪Set NewTrip = New CCar‬‬
  ‫)05(‪Print NewTrip.GetCost‬‬

  ‫اﺻﺒﺤﺖ ﺑﺎﻟﻄﺎﺋﺮة ‘ ‪Set NewTrip = New CPlane‬‬
  ‫)05(‪Print NewTrip.GetCost‬‬
‫‪End Sub‬‬

‫ﺳﺘﻼﺣﻆ اﺧﺘﻼف اﻟﺘﻜﺎﻟﻴﻒ ﺑﻴﻦ رﺣﻠﺔ ﺑﺎﻟﺴﻴﺎرة واﺧـﺮى ﺑﺎﻟﻄـﺎﺋﺮة وﻟـﻮ آﺎﻧـﺖ اﻟﻤﺴـﺎﻓﺔ‬
                                                        ‫ﻣﺘﺸﺎﺑﻬﻪ )05 آﻴﻠﻮ ﻣﺘﺮ(.‬


                                                                                       ‫اﻟﻮراﺛﺔ‬
    ‫ـ‬      ‫ـ‬                ‫ـ‬       ‫ـ‬       ‫ـ‬         ‫ـ‬                     ‫ـ‬
‫اﻟﻮراﺛ ـﺔ ‪ Inheritance‬ه ـﻲ ﻗ ـﺪرة اﻟﻔﺌ ـﺔ –اﻟﻔﺌ ـﺔ اﻟﻤﺸ ـﺘﻘﺔ ‪ -Derived‬ﻋﻠ ـﻰ اﺷ ـﺘﻘﺎق‬
‫اﻋﻀﺎء ﻓﺌﺔ اﺧﺮى -اﻟﻔﺌﺔ اﻻم ‪ -Base Class‬ﺑﺤﻴﺚ ﺗﺘﻤﻜﻦ اﻟﻔﺌﺔ اﻟﻤﺸﺘﻘﺔ ﻣـﻦ اﻟﻮﺻـﻮل‬
‫اﻟﻰ ﺟﻤﻴﻊ اﻋﻀﺎء )ﻃﺮق/ﺧﺼﺎﺋﺺ( اﻟﻔﺌﺔ اﻻم، ﻣﻤﺎ ﻳﺆدي اﻟﻰ ﺗﻄﻮﻳﺮ اﻟﻔﺌﺔ اﻻم واآﻤﺎل‬
‫ﻧﻮاﻗﺼﻬﺎ. ﻓﻤﺜﻼ ﻟﻮ آﺎن ﻟﺪﻳﻨﺎ اﻟﻔﺌﺔ س وﻧﺮﻳﺪ اﺿﺎﻓﺔ اﻟﺨﺎﺻﻴﺔ ص ﻓﻴﻬﺎ، ﻓﻼ ﻳﻮﺟﺪ داﻋـﻲ‬
‫ﻣﻦ اﻋﺎدة ﺑﻨﺎء اﻟﻔﺌﺔ س ﻣﻦ ﺟﺪﻳـﺪ، واﻧﻤـﺎ ﻧﻨﺸـﺊ ﻓﺌـﺔ ع ﺗﺤﺘـﻮي ﻋﻠـﻰ اﻟﺨﺎﺻـﻴﺔ ص‬
‫وﺗﻜﻮن اﻟﻔﺌﺔ ع ﻣﺸﺘﻘﺔ ﻣﻦ اﻟﻔﺌﺔ س ﺑﺤﻴﺚ ﺗﻤﺘﻠﻚ آﺎﻓﺔ ﺧﺼﺎﺋﺼـﻬﺎ اﻻﺧـﺮى. ﻟﺘﻮﺿـﻴﺢ‬
                                       ‫اﻟﻔﻜﺮة، اﻓﺘﺮض ان ﻟﺪﻳﻨﺎ هﺬﻩ اﻟﻔﺌﺎت اﻟﺜﻼث:‬

                  ‫1( اﺳﻢ اﻟﻔﺌﺔ: ‪ ،CPerson‬ﺧﺼﺎﺋﺼﻬﺎ: ‪ Name‬و ‪ ،Age‬ﻃﺮﻗﻬﺎ: ‪Move‬‬

             ‫2( اﺳﻢ اﻟﻔﺌﺔ: ‪ ،CStudent‬ﺧﺼﺎﺋﺼﻬﺎ: ‪ ،Major‬ﻃﺮﻗﻬﺎ: ‪ChangeCollege‬‬

     ‫3( اﺳﻢ اﻟﻔﺌﺔ: ‪ ،CWorkman‬ﺧﺼﺎﺋﺼﻬﺎ: ‪ ،Salary‬ﻃﺮﻗﻬﺎ: ‪ChangeDepartment‬‬
                                               ‫971‬


‫ﺳﻨﻄﺒﻖ ﻋﻠﻴﻬـﺎ ﻣﺒـﺪأ اﻟﻮراﺛـﺔ اﻻن ﺑﺠﻌـﻞ اﻟﻔﺌﺘـﻴﻦ ‪ CWorkman‬و ‪ CStudent‬ﻣﺸـﺘﻘﺔ‬
‫ووارﺛﺔ ﻻﻋﻀﺎء اﻟﻔﺌﺔ اﻻم ‪ .CPerson‬أي ان اﻟﻔﺌﺘـﺎن ‪ CStudent‬و ‪ CWorkman‬ﻗﺎﺑﻠﺘـﺎن‬
 ‫ـ‬        ‫ـ‬     ‫ـ‬       ‫ـ‬
‫ﻟﻠﻮﺻ ـﻮل اﻟ ـﻰ اﻋﻀ ـﺎء اﻟﻔﺌ ـﺔ اﻻم ‪ ،CPerson‬ﻟ ـﺬﻟﻚ ﺟﻤﻴ ـﻊ ه ـﺬﻩ اﻻآ ـﻮاد ﺻ ـﺤﻴﺤﺔ ﻣ ـﻦ‬
                             ‫ـ‬        ‫ـ‬                 ‫ـ‬        ‫ـ‬       ‫ـ‬     ‫ـ‬
                                                                   ‫اﻟﻨﺎﺣﻴﺔ اﻟﻤﻨﻄﻘﻴﺔ:‬

‫”ﻣﺤﻤﺪ“ = ‪CStudent.Name‬‬
‫52 = ‪CStudent.Age‬‬
‫)(‪CStudent.Move‬‬
‫”ﻋﻠﻮم اﻟﺤﺎﺳﺐ“ = ‪CStudent.Major‬‬
‫)(‪CStudent.ChangeCollege‬‬

‫”ﻋﺒﺪاﷲ“ = ‪CStudent.Name‬‬
‫03 = ‪CWorkman.Age‬‬
‫)(‪CWorkman.Move‬‬
‫000,01 = ‪CWorkman.Salary‬‬
‫)(‪CWorkman.ChangeDepartment‬‬

‫واﻟﺴﺒﺐ ﻓﻲ ذﻟﻚ، ان اﻟﻔﺌﺎت اﻟﻤﺸﺘﻘﺔ ‪ CWorkman‬و ‪ CStudent‬ﻗﺎﺑﻠﺔ ﻟﻠﻮﺻﻮل اﻟـﻰ‬
                 ‫ـ‬         ‫ـ‬    ‫ـ‬     ‫ـ‬                     ‫ـ‬       ‫ـ‬        ‫ـ‬
‫ﺟﻤﻴ ـﻊ ﻋﻨﺎﺻ ـﺮ اﻟﻔﺌ ـﺔ اﻻم ‪ ،CPerson‬واﻟﻌﻜ ـﺲ ﻏﻴ ـﺮ ﺻ ـﺤﻴﺢ! ﻓﺎﻟﻔﺌ ـﺔ اﻻم ‪ CPerson‬ﻻ‬
‫ﺗﺴﺘﻄﻴﻊ اﻟﻮﺻﻮل اﻟﻰ اﻋﻀﺎء اﻟﻔﺌﺔ اﻟﻤﺸﺘﻘﺔ ﻣﻨﻬﺎ، ﻓﻼ ﺗﻜﺘﺐ ﻓﻲ اﺣﺪ اﻻﻳﺎم ﺷﻴﺌﺎ ﻣﻦ‬
                                                                      ‫هﺬا اﻟﻘﺒﻴﻞ:‬

‫000,02 = ‪CPerson.Salary‬‬
‫او ‘‬
‫)(‪CPerson.ChangeCollege‬‬

‫اﻟﻤﺰﻳﺪ اﻳﻀﺎ، اﻟﻔﺌﺎت اﻟﻤﺸـﺘﻘﺔ ﺗـﺮث ﻣـﻦ اﻟﻔﺌـﺎت اﻟﻤﺸـﺘﻖ ﻣﻨﻬـﺎ )اﻟﻔﺌـﺎت اﻻم( ﻓﻘـﻂ.‬
‫ﻓﻔــﻲ ﻣﺜﺎﻟﻨــﺎ اﻟﺴــﺎﺑﻖ، اﻟﻔﺌــﺎت ‪ CStudent‬و ‪ CWorkman‬ﻻ ﻳﻤﻜــﻦ ﻻي ﻓﺌــﺔ ﻣﻨﻬــﺎ‬
                              ‫اﻟﻮﺻﻮل اﻟﻰ اﻋﻀﺎء اﻟﻔﺌﺔ اﻻﺧﺮى ﻓﻼ ﺗﻜﺘﺐ ﻣﺜﻞ هﺬا:‬

‫000,01 = ‪CStudent.Salary‬‬
‫)(‪CWorkman.ChangeCollege‬‬

‫ﻻﻧﻬﻤﺎ ﻣﺸﺘﻘﺎن ﻣﻦ اﻟﻔﺌﺔ اﻻم ‪ CPerson‬ﻓﻘﻂ. وهﺬا ﺑﺎﺧﺘﺼﺎر ﻣﻔﻬﻮم ﻣﺒﺪأ اﻟﻮراﺛﺔ ﻓـﻲ‬
‫ﺟﻤﻴﻊ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ واﻟﺬي ﻳﻘﺪم ﻟﻚ اﻟﻜﺜﻴﺮ ﻣﻦ اﺧﺘﺼﺎر آﺘﺎﺑﺔ اﻻآـﻮاد واﻟﺘﺴـﻬﻴﻞ ﻓـﻲ‬
                                             ‫081‬


‫ﻋﻤﻠﻴﺔ اﻟﺘﻨﻘﻴﺢ وﺗﻄﻮﻳﺮ اﻟﻔﺌﺔ ﻧﻔﺴﻬﺎ اﻳﻀـﺎ، ﺗﺨﻴـﻞ ﻣـﺜﻼ ان ﻟـﺪﻳﻚ ﻓﺌـﺔ ‪ MyClass‬واردت‬
‫ﺗﻄﻮﻳﺮهﺎ ﺑﺎﺿﺎﻓﺔ ﻋﻨﺎﺻﺮ ﺟﺪﻳﺪة ﻟﻬﺎ، آﻞ ذﻟﻚ ﻳﻤﻜﻦ ان ﻳـﺘﻢ ﻋـﻦ ﻃﺮﻳـﻖ اﺷـﺘﻘﺎق ﻓﺌـﺔ‬
                                                ‫اﺧﺮى ﺟﺪﻳﺪة ﻣﻨﻬﺎ واﺿﺎﻓﺔ اﻟﻼزم.‬

                                      ‫ﻣﺤﺎآﺎة اﻟﻮراﺛﺔ ﺑـ ‪Visual Basic‬‬
‫ﻟﻼﺳﻒ اﻟﺸﺪﻳﺪ ‪ Visual Basic‬ﻻ ﻳﺪﻋﻢ ﻣﺒﺪأ اﻟﻮراﺛﺔ ﺑﺸﻜﻞ ﺿـﻤﻨﻲ، واﻟـﺬي ﺳـﻨﻔﻌﻠﻪ‬
‫هﻨﺎ ﻋﻤﻠﻴﺔ ﻣﺤﺎآﺎة ﻣﺒﺪأ اﻟﻮراﺛﺔ ﻋﻠﻰ اﻟﻔﺌﺎت. اﻟﻔﻜﺮة ﻓﻲ ﻣﺤﺎآﺎة اﻟﻮراﺛﺔ ﺳﻬﻠﺔ، ﻓﺒﻤـﺎ‬
‫ان اﻟﻔﺌﺎت اﻟﻤﺸﺘﻘﺔ ﺳـﺘﺮث ﻧﻔـﺲ اآـﻮاد اﻟﻔﺌـﺎت اﻻم، ﻓﻠﻤـﺎذا ﻻ ﻧﻘـﻮم ﺑﻨﺴـﺦ ﺟﻤﻴـﻊ‬
‫ﻣﺤﺘﻮﻳﺎت اﻟﻔﺌﺔ اﻻم وﻟﺼﻘﻬﺎ ﻓﻲ اﻟﻔﺌﺎت اﻟﻤﺸﺘﻘﺔ. ﻟﺘﻄﺒﻴﻖ ذﻟـﻚ، اﻧﺸـﺊ ﻓﺌـﺔ ﺑﺎﺳـﻢ‬
                                                 ‫‪ CPerson‬واآﺘﺐ ﻓﻴﻬﺎ هﺬا اﻟﻜﻮد:‬

‫‪Private m_sName As String‬‬
‫‪Private m_iAge As Integer‬‬

‫)(‪Sub Move‬‬
  ‫"ﺗﻢ ﺗﻨﻔﻴﺬ اﺟﺮاء اﻟﺘﺤﺮﻳﻚ" ‪MsgBox‬‬
‫‪End Sub‬‬

‫‪Property Get iAge () As Integer‬‬
  ‫‪iAge = m_iAge‬‬
‫‪End Property‬‬

‫) ‪Property Let iAge ( iNewValue As Integer‬‬
  ‫‪m_iAge = iNewValue‬‬
‫‪End Property‬‬

‫‪Property Get sName () As String‬‬
  ‫‪sName = m_sName‬‬
‫‪End Property‬‬

‫) ‪Property Let sName ( sNewValue As String‬‬
  ‫‪m_sName = sNewValue‬‬
‫‪End Property‬‬
                                              181


‫ وﻟﺼـﻘﻬﺎ‬CPerson ‫، ﻗﻢ ﺑﻨﺴﺦ ﺟﻤﻴـﻊ ﻣﺤﺘﻮﻳـﺎت اﻟﻔﺌـﺔ اﻻم‬CStudent ‫وﻻﻧﺸﺎء ﻓﺌﺔ اﻟـ‬
                                                       :‫ﻓﻲ اﻟﻔﺌﺔ اﻟﻤﺸﺘﻘﺔ‬

‘ ‫ﺧﺼﺎﺋﺺ اﻟﻔﺌﺔ اﻻم‬
Private m_sName As String
Private m_iAge As Integer

Property Get iAge () As Integer
  iAge = m_iAge
End Property

Property Let iAge ( iNewValue As Integer )
  m_iAge = iNewValue
End Property

Property Get sName () As String
  sName = m_sName
End Property

Property Let sName ( sNewValue As String )
  m_sName = sNewValue
End Property

‘ ‫ﺧﺼﺎﺋﺺ اﻟﻔﺌﺔ اﻟﻤﺸﺘﻘﺔ‬
Private m_sMajor As String

Property Get sMajor () As String
  sName = m_sName
End Property

Property Let sMajor ( sNewValue As String )
  m_sName = sNewValue
End Property

‘ ‫ﻃﺮق اﻟﻔﺌﺔ اﻻم‬
Sub Move()
   MsgBox "‫"ﺗﻢ ﺗﻨﻔﻴﺬ اﺟﺮاء اﻟﺘﺤﺮﻳﻚ‬
                                               182


End Sub

‘ ‫ﻃﺮق اﻟﻔﺌﺔ اﻟﻤﺸﺘﻘﺔ‬
Sub ChangeCollege()
   MsgBox "‫"ﺗﻢ ﺗﻨﻔﻴﺬ اﺟﺮاء ﺗﺤﻮﻳﻞ اﻟﻜﻠﻴﺔ‬
End Sub

                                          :CWorkman ‫ﻧﻔﺲ اﻟﻔﻜﺮة ﻃﺒﻘﻬﺎ ﻋﻠﻰ اﻟﻔﺌﺔ‬

‘ ‫ﺧﺼﺎﺋﺺ اﻟﻔﺌﺔ اﻻم‬
Private m_sName As String
Private m_iAge As Integer

Property Get iAge () As Integer
  iAge = m_iAge
End Property

Property Let iAge ( iNewValue As Integer )
  m_iAge = iNewValue
End Property

Property Get sName () As String
  sName = m_sName
End Property

Property Let sName ( sNewValue As String )
  m_sName = sNewValue
End Property

‘ ‫ﺧﺼﺎﺋﺺ اﻟﻔﺌﺔ اﻟﻤﺸﺘﻘﺔ‬
Private m_lSalary As Long

Property Get lSalary () As Long
  lSalary = m_lSalary
End Property

Property Let lSalary ( lNewValue As Long )
                                            ‫381‬


  ‫‪m_lSalary = lNewValue‬‬
‫‪End Property‬‬

‫ﻃﺮق اﻟﻔﺌﺔ اﻻم ‘‬
‫)(‪Sub Move‬‬
   ‫"ﺗﻢ ﺗﻨﻔﻴﺬ اﺟﺮاء اﻟﺘﺤﺮﻳﻚ" ‪MsgBox‬‬
‫‪End Sub‬‬

‫ﻃﺮق اﻟﻔﺌﺔ اﻟﻤﺸﺘﻘﺔ ‘‬
‫)(‪Sub ChangeDepartment‬‬
   ‫"ﺗﻢ ﺗﻨﻔﻴﺬ اﺟﺮاء ﺗﻐﻴﻴﺮ اﻟﻘﺴﻢ" ‪MsgBox‬‬
‫‪End Sub‬‬

                  ‫واﻻن ﻗﻤﻨﺎ ﺑﻌﻤﻠﻴﺔ ﻣﺤﺎآﺎة ﻣﺒﺪأ اﻟﻮراﺛﺔ، ﻓﺘﺴﺘﻄﻴﻊ آﺘﺎﺑﺔ اآﻮاد ﻣﺜﻞ:‬

‫‪Dim X As New CStudent‬‬
‫‪Dim Y As New CWorkman‬‬

‫”ﻣﺤﻤﺪ“ = ‪X.sName‬‬
‫52 = ‪X.iAge‬‬
‫)(‪X.Move‬‬
‫”ﻋﻠﻮم اﻟﺤﺎﺳﺐ“ = ‪X.sMajor‬‬
‫)(‪X.ChangeCollege‬‬

‫”ﻋﺒﺪاﷲ“ = ‪Y.sName‬‬
‫03 = ‪Y.iAge‬‬
‫)(‪Y.Move‬‬
‫000,01 = ‪Y.lSalary‬‬
‫)(‪Y.ChangeDepartment‬‬

                                                   ‫ﻋﻼﻗﺔ "ﻳﺤﺘﻮي ﻋﻠﻰ"‬
‫اﻟﻤﺸﻜﻠﺔ ﻓﻲ ﻓﻜﺮة اﻟﻤﺤﺎآﺎة اﻟﺴﺎﺑﻘﺔ هﻲ ﺿﺮورة وﺟﻮد اﻟﺸﻴﻔﺮة اﻟﻤﺼﺪرﻳﺔ ‪Source‬‬
‫‪ Code‬ﻟﻠﻔﺌﺔ اﻻم ﺣﺘﻰ ﺗﺘﻤﻜﻦ ﻣﻦ اﺷﺘﻘﺎق اﻟﻔﺌﺎت ﻣﻨﻬﺎ. اﻣﺎ ﻓﻲ ﺣﺎﻟﺔ آﻮن اﻟﻔﺌﺔ ﻓﻲ‬
‫ﻣﻠﻒ ﺗﻨﻔﻴﺬي -آﺪاﺧﻞ ﻣﻜﻮن ‪ COM‬ﻣﺜﻼ- ﻓﺎﻟﻌﻤﻠﻴﺔ ﻣﻌﻘﺪة ﺟﺪا -ان ﻟﻢ ﺗﻜﻦ ﻣﺴﺘﺤﻴﻠﺔ.‬
‫واﻟﺤﻞ ﻋﻦ ﻃﺮﻳﻖ ﺗﻄﺒﻴﻖ ﻋﻼﻗﺔ ﺗﻌﺮف ﻓﻲ ﻋﺎﻟﻢ اﻟﺒﺮﻣﺠﺔ آﺎﺋﻨﻴـﺔ اﻟﺘﻮﺟـﻪ ‪ OOP‬ﺑﺎﺳـﻢ‬
‫ﻳﺤﺘﻮي ﻋﻠﻰ ‪ Has a‬وهﻲ ﺗﻨﺺ ﺑﺎﺧﺘﺼﺎر ﻋﻠﻰ ان اﻟﻔﺌـﺔ ﻳﻤﻜـﻦ ﻟﻬـﺎ ان ﺗﺤﺘـﻮي ﻋﻠـﻰ‬
                                              ‫481‬


‫آﺎﺋﻦ ﻣﻦ ﻓﺌﺔ اﺧﺮى ﻋﻦ ﻃﺮﻳﻖ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ ﻳﻤﺜﻞ آﺎﺋﻦ ﻟﺘﻠـﻚ اﻟﻔﺌـﺔ. اﻻن ﻗـﻢ ﺑﺎﻋـﺎدة‬
                   ‫ﺗﺼﻤﻴﻢ اﻟﻔﺌﺎت اﻟﻤﺸﺘﻘﺔ ‪ CStudent‬و ‪ CWorkman‬ﺑﻬﺬﻩ اﻟﻄﺮﻳﻘﺔ:‬

‫اﻟﻔﺌﺔ اﻻم ‘‬
‫‪Public objPerson As New CPerson‬‬

‫ﺧﺼﺎﺋﺺ اﻟﻔﺌﺔ اﻟﻤﺸﺘﻘﺔ ‘‬
‫‪Private m_sMajor As String‬‬

‫‪Property Get sMajor () As String‬‬
  ‫‪sName = m_sName‬‬
‫‪End Property‬‬

‫) ‪Property Let sMajor ( sNewValue As String‬‬
  ‫‪m_sName = sNewValue‬‬
‫‪End Property‬‬

‫ﻃﺮق اﻟﻔﺌﺔ اﻟﻤﺸﺘﻘﺔ ‘‬
‫)(‪Sub ChangeCollege‬‬
   ‫"ﺗﻢ ﺗﻨﻔﻴﺬ اﺟﺮاء ﺗﺤﻮﻳﻞ اﻟﻜﻠﻴﺔ" ‪MsgBox‬‬
‫‪End Sub‬‬

‫اﻟﻌﻴﺐ اﻟﻮﺣﻴﺪ ﻓﻲ هﺬﻩ اﻟﻄﺮﻳﻘﺔ هﻮ ان اﻟﻤﺴﺘﺨﺪم ﻟﻬﺬﻩ اﻟﻔﺌـﺔ ﻟـﻦ ﻳﺴـﺘﻄﻴﻊ ﻣﺤﺎآـﺎة‬
‫اﻟﻮراﺛﺔ ﺑﺸﻜﻠﻬﺎ اﻟﺼﺤﻴﺢ، ﻓﻠـﻦ ﻳﺴـﺘﻄﻴﻊ آﺘﺎﺑـﺔ اﻟﻌﺒـﺎرة ﻣـﺜﻼ ‪ X.sName‬ﻟﻠﻮﺻـﻮل اﻟـﻰ‬
‫اﻋﻀﺎء اﻟﻔﺌﺔ اﻻم، واﻧﻤﺎ ﺳﻴﻀﻄﺮ اﻟﻰ اﺳﺘﺨﺪام اﻟﻜﺎﺋﻦ اﻟﻤﺤﻀﻮن ﻓﻲ اﻟﻔﺌﺔ اﻟﻤﺸـﺘﻘﺔ‬
                                                  ‫وآﺘﺎﺑﺔ ‪.X.objPerson.sName‬‬

                                                    ‫اﻟﺘﻔﻮﻳﺾ ‪Delegation‬‬
‫ﻳﺒﺪو ان اﻟﺤﻞ اﻻﻣﺜﻞ هﻮ ﺑﺠﻌﻞ آﺎﺋﻦ اﻟﻔﺌﺔ اﻻم ﻣﺨﻔـﻲ وﻣﺤﺎآـﺎة ﺟﻤﻴـﻊ اﻋﻀـﺎءﻩ ﻓـﻲ‬
‫اﻟﻔﺌﺔ اﻟﻤﺸﺘﻘﺔ، وﻣﻦ ﺛﻢ ارﺳﺎﻟﻬﺎ اﻟﻰ اﻟﻜﺎﺋﻦ، وهﺬﻩ هﻲ اﻟﻔﻜﺮة اﻻﺳﺎﺳﻴﺔ ﻣﻦ ﻣﺒـﺪأ‬
                    ‫اﻟﺘﻔﻮﻳﺾ، ﻓﺴﻴﺼﺒﺢ اﻟﻜﻮد اﻟﻨﻬﺎﺋﻲ ﻟﻠﻔﺌﺔ اﻟﻤﺸﺘﻘﺔ ‪:CStudent‬‬

‫اﻟﻔﺌﺔ اﻻم ‘‬
‫‪Private objPerson As New CPerson‬‬

‫ﺗﻔﻮﻳﺾ ﺧﺼﺎﺋﺺ اﻟﻔﺌﺔ اﻻم ‘‬
                                              185


Property Get iAge () As Integer
  iAge = objPerson.iAge
End Property

Property Let iAge ( iNewValue As Integer )
  objPerson.iAge = iNewValue
End Property

Property Get sName () As String
  sName = objPerson.sName
End Property

Property Let sName ( sNewValue As String )
  objPerson.sName = sNewValue
End Property

‘ ‫ﺧﺼﺎﺋﺺ اﻟﻔﺌﺔ اﻟﻤﺸﺘﻘﺔ‬
Private m_sMajor As String

Property Get sMajor () As String
  sName = m_sName
End Property

Property Let sMajor ( sNewValue As String )
  m_sName = sNewValue
End Property

‘ ‫ﺗﻔﻮﻳﺾ ﻃﺮق اﻟﻔﺌﺔ اﻻم‬
Sub Move()
   objPerson.Move
End Sub

‘ ‫ﻃﺮق اﻟﻔﺌﺔ اﻟﻤﺸﺘﻘﺔ‬
Sub ChangeCollege()
   MsgBox "‫"ﺗﻢ ﺗﻨﻔﻴﺬ اﺟﺮاء ﺗﺤﻮﻳﻞ اﻟﻜﻠﻴﺔ‬
End Sub
                                             ‫681‬


‫واﻻن ﻗﻤﺖ ﺑﻤﺤﺎآﺎة ﻣﺒﺪأ اﻟﻮراﺛﺔ ﻓﻲ ‪ Visual Basic‬ﻟﻜـﻦ -ﻣـﻊ اﻻﺳـﻒ- اود ان اﺧﺒـﺮك‬
‫ان اﻟﺬي ﻓﻌﻠﻨﺎﻩ ﺻﺤﻴﺢ 001% ﻓﻲ هﺬا اﻟﻤﺜﺎل ﻓﻘﻂ! ﻻﻧـﻪ ﻓـﻲ ﺣﺎﻟـﺔ آـﻮن ﻟﻠﻔﺌـﺔ اﻻم‬
‫واﺟﻬﺔ ﻓﺮﻋﻴﺔ ﻣﻦ واﺟﻬﺔ اﺧﺮى -ﻣﺒﺪأ ﺗﻌﺪد اﻟﻮاﺟﻬـﺎت ‪ -Polymorphism‬ﻟـﻦ ﺗﺴـﺘﻄﻴﻊ‬
           ‫اﻟﻮﺻﻮل اﻟﻰ اﻋﻀﺎء اﻟﻮاﺟﻬﺔ اﻻﺧﺮى ﻟﻠﻔﺌﺔ، واﻟﺤﻞ ﺗﺠﺪﻩ ﻓﻲ اﻟﻔﻘﺮة اﻟﺘﺎﻟﻴﺔ.‬

                                                             ‫وراﺛﺔ اﻟﻮاﺟﻬﺎت‬
‫ارﻳﺪ ان اﺑﺪأ هﻨﺎ ﺗﻘﺪﻳﻢ ﻣﺤﺘﻮﻳﺎت اﻟﻤﺜـﺎل اﻟـﺬي ﺳـﻴﻈﻬﺮ ﻟﻨـﺎ ﻣﺸـﻜﻠﺔ وراﺛـﺔ اﻟﻮاﺟﻬـﺎت‬
‫وآﻴﻔﻴﺔ ﺗﻼﻓﻴﻬﺎ، ﺳﻴﻜﻮن ﻟﺪﻳﻨﺎ ﻓﻲ هﺬا اﻟﻤﺜﺎل واﺟﻬـﺔ واﺣـﺪة ﺑﺎﺳـﻢ ‪ IMyInterface‬و‬
                    ‫ﻓﺌﺔ ام ﺑﺎﺳﻢ ‪ CBaseClass‬وﻓﺌﺔ ﻣﺸﺘﻘﺔ ﺑﺎﺳﻢ ‪.CDerivedClass‬‬

‫اﻟﻮاﺟﻬﺔ ‪ IMyInterface‬ﺗﺤﺘﻮي ﻋﻠـﻰ اﺟـﺮاء ﺑﺎﺳـﻢ ‪ ،MyMethod‬واﻟﻔﺌـﺔ اﻻم ﺗﺤﺘـﻮي‬
‫ﻋﻠﻰ اﺟﺮاء ﺑﺎﺳﻢ ‪ .BaseMethod‬واﺧﻴﺮا، اﻟﻔﺌﺔ اﻟﻤﺸﺘﻘﺔ ﺗﺤﺘـﻮي ﻋﻠـﻰ اﺟـﺮاء ﺑﺎﺳـﻢ‬
‫‪ ،DerivedMethod‬ﺿﻊ ﻓـﻲ ﻋـﻴﻦ اﻻﻋﺘﺒـﺎر ﻋﻠـﻰ ان اﻟﻔﺌـﺔ اﻻم ﺗﺤﺘـﻮي ﻋﻠـﻰ واﺟﻬـﺔ‬
‫اﺿﺎﻓﻴﺔ ﻣﻦ اﻟﻮاﺟﻬﺔ ‪ IMyInterface‬أي ان اﻟﻄﺮق اﻟﺘﺎﺑﻌﺔ ﻟﻠﻜﺎﺋﻦ ﻣـﻦ اﻟﻔﺌـﺔ اﻻم هـﻲ‬
                                                   ‫‪ MyMethod‬و ‪.BaseMethod‬‬

                                                               ‫ﺗﻮﺿﻴﺢ اﻟﻤﺸﻜﻠﺔ:‬
‫ﺣﺘﻰ ﻧﻘﻮم ﺑﺤﻞ اﻟﻤﺸﻜﻠﺔ ﻻﺑﺪ ﺑﻜﻞ ﺗﺄآﻴﺪ ﻣﻦ ﻣﻌﺮﻓﺔ ﻣﺎهﻲ اﻟﻤﺸـﻜﻠﺔ. اﻻن ﺳـﻨﻘﻮم‬
 ‫ـ‬                ‫ـ‬                ‫ـ‬                      ‫ـ‬
‫ﺑﻌﻤﻠﻴـﺔ اﻟﺘﻔـﻮﻳﺾ -ﻟﻤﺤﺎآـﺎة اﻟﻮراﺛـﺔ- آﻤـﺎ ﻋﻤﻠﻨـﺎ ﻓـﻲ اﻟﻔﻘـﺮة اﻟﺴـﺎﺑﻘﺔ وﺟﻌـﻞ اﻟﻔﺌـﺔ‬
‫‪ CDerivedClass‬ﻣﺸﺘﻘﺔ ﻣـﻦ اﻟﻔﺌـﺔ اﻻم ‪ ،CBaseClass‬ﻟﻴﺼـﺒﺢ اﻟﻜـﻮد اﻟﻨﻬـﺎﺋﻲ ﻟﻠﻔﺌـﺔ‬
                                                              ‫‪ CDerivedClass‬هﻮ:‬

‫‪Private BaseClass As New CBaseClass‬‬

‫ﺗﻔﻮﻳﺾ ﻃﺮق اﻟﻔﺌﺔ اﻻم ‘‬
‫)(‪Sub BaseMethod‬‬
   ‫‪BaseClass.BaseMethod‬‬
‫‪End Sub‬‬

‫ﻃﺮق اﻟﻔﺌﺔ اﻟﻤﺸﺘﻘﺔ ‘‬
‫)(‪Sub DerivedMethod‬‬
      ‫اآﺘﺐ ﻣﺎ ﺗﺮﻳﺪﻩ هﻨﺎ ‘‬
‫‪End Sub‬‬
                                             ‫781‬


‫ﻳﺒــﺪو ان اﻟﻤﺸــﻜﻠﺔ اﺗﻀــﺤﺖ ﻟــﻚ اﻻن وهــﻲ ان اﻟﻔﺌــﺔ اﻟﻤﺸــﺘﻘﺔ ﻻ ﺗــﺪﻋﻢ اﻟﻄﺮﻳﻘــﺔ‬
‫‪ MyMethod‬اﻟﺘﺎﺑﻌﺔ ﻟﻠﻮاﺟﻬـﺔ ‪ IMyInterface‬واﻟﺘـﻲ ﺗﻌﺘﺒـﺮ اﺣـﺪى واﺟﻬـﺎت اﻟﻔﺌـﺔ اﻻم‬
                         ‫‪ .CBaseClass‬اذا آﻨﺖ ﺗﻔﻜﺮ ﺑﺘﻔﻮﻳﺾ اﺟﺮاء ﻟﻌﻤﻞ ذﻟﻚ آﻬﺬا:‬

‫)(‪Sub MyMethod‬‬
  ‫‪BaseClass.MyMethod‬‬
‫‪End Sub‬‬

‫ﻓﺎرﺟﻮ ان ﺗﻮﻗﻒ اﻟﻘﺮاءة ﻓﻲ اﻟﺤﺎل! ﻻﻧﻚ ﺑﺤﺎﺟـﺔ ﻣﺎﺳـﺔ اﻟـﻰ ﻣﻌﺮﻓـﺔ واﺳـﺘﻴﻌﺎب ﻣﺒـﺪأ‬
‫ﺗﻌﺪد اﻟﻮاﺟﻬﺎت ‪ ،Polymorphism‬ﻓﺎﻟﻜـﺎﺋﻦ ‪ BaseClass‬ﻣﻌـﺮف ﻣـﻦ اﻟﻔﺌـﺔ ‪CBaseClass‬‬
                       ‫وﻟﻴﺲ ﻣﻦ اﻟﻮاﺟﻬﺔ ‪ IMyInterface‬وﻟﻦ ﺗﺴﺘﻄﻴﻊ ﻋﻤﻞ ذﻟﻚ.‬

                                                              ‫ﺣﻞ اﻟﻤﺸﻜﻠﺔ:‬
‫اﺗﻤﻨﻰ ان ﺗﻜـﻮن اﻟﻤﺸـﻜﻠﺔ ﻗـﺪ اﺗﻀـﺤﺖ ﻟـﻚ، ﻳﻜﻤـﻦ اﻟﺤـﻞ ﺑـﺎﻻﻟﺘﺰام ﺑﻌﻤﻠﻴـﺔ ﺗﻀـﻤﻴﻦ‬
    ‫اﻟﻮاﺟﻬﺔ ‪ IMyInterface‬ﻓﻲ اﻟﻔﺌﺔ اﻟﻤﺸﺘﻘﺔ، وﻳﺼﺒﺢ اﻟﻜﻮد اﻟﻨﻬﺎﺋﻲ ﺑﻬﺬا اﻟﺸﻜﻞ:‬

‫‪Private BaseClass As New CBaseClass‬‬
‫ﻻﺑﺪ ﻣﻦ ﺗﻀﻤﻴﻦ ﺗﻠﻚ اﻟﻮاﺟﻬﺔ ‘‬
‫‪Implements IMyInterface‬‬

‫ﺗﻔﻮﻳﺾ ﻃﺮق اﻟﻔﺌﺔ اﻻم ‘‬
‫)(‪Sub BaseMethod‬‬
   ‫‪BaseClass.BaseMethod‬‬
‫‪End Sub‬‬

‫ﺗﻔﻮﻳﺾ اﻟﻮاﺟﻬﺔ اﻻﺧﺮى ﻟﻠﻔﺌﺔ اﻻم ‘‬
‫)(‪Private Sub IMyInterface_MyMethod‬‬
   ‫‪Dim TempInf As IMyInterface‬‬

  ‫‪Set TempInf = BaseClass‬‬
  ‫اﻻن ﻳﻤﻜﻨﻚ ﻋﻤﻞ ذﻟﻚ ‘ ‪TempInf.MyMethod‬‬
‫‪End Sub‬‬

‫)(‪Sub MyMethod‬‬
  ‫‪IMyInterface_MyMethod‬‬
‫‪End Sub‬‬
                                               ‫881‬



‫ﻃﺮق اﻟﻔﺌﺔ اﻟﻤﺸﺘﻘﺔ ‘‬
‫)(‪Sub DerivedMethod‬‬
‫اآﺘﺐ ﻣﺎ ﺗﺮﻳﺪﻩ هﻨﺎ ‘‬
‫‪End Sub‬‬

                                        ‫اﻟﺘﺼﻨﻴﻒ اﻟﻔﺮﻋﻲ ‪Subclassing‬‬
‫ﻋﻤﻠﻴﺔ اﻟﺘﻔﻮﻳﺾ ‪ Delegation‬ﺑﻼ ﺷﻚ ﻏﻴﺮ ﻣﻘﺒﻮﻟﺔ ﺑﺸـﻜﻞ آﺒﻴـﺮ ﻟـﺪى ﻣﺒﺮﻣﺠـﻲ ‪OOP‬‬
‫وﺑﺎﻟﺘﺤﺪﻳﺪ ﻣﺴﺘﺨﺪﻣﻮا ﻣﺒـﺪأ اﻟﻮراﺛـﺔ ﺑﻜﺜـﺮة، اﻻ اﻧﻬـﺎ ﺗﺘﻤﻴـﺰ ﺑﺎﻋﻄـﺎءك ﺗﺤﻜـﻢ اآﺒـﺮ ﻗﺒـﻞ‬
‫ﺗﻨﻔﻴﺬ اﻻﺟﺮاء اﻟﺘﺎﺑﻊ ﻟﻠﻔﺌـﺔ اﻻم ﻣـﻦ داﺧـﻞ اﻟﻔﺌـﺔ اﻟﻤﺸـﺘﻘﺔ. ﻓﻤـﺜﻼ، اﻟﻔﺌـﺔ اﻟﻤﺸـﺘﻘﺔ‬
                                                               ‫ﺗﺤﺘﻮي ﻋﻠﻰ هﺬا اﻟﻜﻮد:‬

‫)(‪Sub BaseMethod‬‬
  ‫‪BaseClass.BaseMethod‬‬
‫‪End Sub‬‬

‫ﻧﻔﺘــﺮض ان اﻟﻄﺮﻳﻘــﺔ اﻟﺴــﺎﺑﻘﺔ ﻋﺒــﺎرة ﻋــﻦ داﻟــﺔ ‪ Function‬وﺗﺤﺘــﻮي ﻋﻠــﻰ ﻣﺘﻐﻴــﺮات‬
                                                                       ‫‪:Parameters‬‬

‫‪Function BaseMethod (X As Long, Y As Long) As Long‬‬
  ‫)‪BaseMethod = BaseClass.BaseMethod (X, Y‬‬
‫‪End Sub‬‬

‫اﻟﺬي آﻨﺖ اﻗﺼﺪﻩ ﻣﻦ اﻟﺘﺤﻜﻢ اﻻآﺒﺮ هﻮ اﻧﻚ ﻓﻲ اﻟﻜﻮد اﻟﺴﺎﺑﻖ ﺗﺴﺘﻄﻴﻊ اﻟﻐﺎء ﻋﻤﻠﻴـﺔ‬
‫اﺳــﺘﺪﻋﺎء اﻟﻄﺮﻳﻘــﺔ اﻟﻤﻮﺟــﻮدة ﻓــﻲ اﻟﻔﺌــﺔ اﻻم او ﺗﻌــﺪﻳﻞ ﻗــﻴﻢ اﻟﻤﺘﻐﻴــﺮات اﻟﻤﺮﺳــﻠﺔ‬
‫‪ Arguments‬او ﺣﺘــﻰ ﺗﻐﻴﻴــﺮ اﻟﻘﻴﻤــﺔ اﻟﺘــﻲ ﺗﻌــﻮد ﺑﻬــﺎ اﻟﻄﺮﻳﻘــﺔ ‪،Returned Value‬‬
                                                       ‫ﻓﺘﺴﺘﻄﻴﻊ ان ﺗﻜﺘﺐ ﺷﻴﺌﺎ ﻣﺜﻞ:‬

‫‪Function BaseMethod (X As Long, Y As Long) As Long‬‬
  ‫‪If X = 0 Then‬‬
     ‫0 = ‪BaseMethod‬‬
  ‫‪ElseIf Y = 0 Then‬‬
     ‫)1 ,‪BaseMethod = BaseClass.BaseMethod (X‬‬
  ‫‪Else‬‬
     ‫)‪BaseMethod = BaseClass.BaseMethod (X, Y‬‬
                                             ‫981‬


  ‫‪End If‬‬
‫‪End Sub‬‬

‫ﻓﻲ ﻣﺒﺪأ اﻟﻮراﺛﺔ، ﺗﺴﻤﻰ هﺬﻩ اﻟﻌﻤﻠﻴﺔ ﺑﺎﻟﺘﺼـﻨﻴﻒ اﻟﻔﺮﻋـﻲ ﻟﻠﻔﺌـﺔ اﻻم ‪Subclassing‬‬
‫‪ ،the base class‬وهﻲ ﻣﻦ اﻟﺘﻘﻨﻴﺎت اﻟﻤﺘﻘﺪﻣﺔ اﻟﺘﻲ ﺗﻮﻓﺮهﺎ ﻟﻚ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ آﺎﺋﻨﻴـﺔ‬
‫اﻟﺘﻮﺟﻪ ‪ OOP‬آﻠﻐﺔ اﻟـ ++‪ C‬واﻟﺘﻲ ﻃﺒﻘﻨﺎهﺎ ﺑﺸﻜﻞ ﻓﻌﺎل ﻓـﻲ ﻟﻐﺘﻨـﺎ اﻟﺠﻤﻴﻠـﺔ ‪Visual‬‬
                                                                          ‫‪.Basic‬‬
‫اﻟﻤﺰﻳﺪ اﻳﻀﺎ، ﻳﻤﻜﻨﻚ ﺗﻄﺒﻴﻖ ﻣﺒﺪأ اﻟﺘﺼﻨﻴﻒ اﻟﻔﺮﻋﻲ ﻋﻠﻰ ﺟﻤﻴـﻊ اﻋﻀـﺎء ﻣﻜﺘﺒـﺎت ‪ VB‬و‬
‫‪ ،VBA‬ﻓﻤﺜﻼ اﻟﺪاﻟﺔ ‪ Hex‬ﺣﺮوف اﻻﻋـﺪاد اﻟﺴﺘﻌﺸـﺮﻳﺔ اﻟﺘـﻲ ﺗﻌـﻮد ﺑﻬـﺎ ﺗﻜـﻮن اﻧﺠﻠﻴﺰﻳـﺔ‬
‫داﺋﻤﺎ ‪ F .... ،B ،A‬وﻗﺪ ﺗﻜﻮن ﻣﻦ اﻟﻤﺘﻌﺼﺒﻴﻦ اﻟـﻰ ﻟﻐﺘﻨـﺎ اﻟﺠﻤﻴﻠـﺔ ﺑﺤﻴـﺚ ﺗـﻮد ان ﺗﻌـﻮد‬
‫اﻟﺪاﻟﺔ ﺑﺎﻟﺤﺮوف اﻟﻌﺮﺑﻴﺔ، ﻓﺘﺴﺘﻄﻴﻊ ﺗﻄﺒﻴﻖ ﻣﺒﺪأ اﻟﺘﺼﻨﻴﻒ اﻟﻔﺮﻋﻲ ﻟﻠﺪاﻟﺔ ‪ Hex‬ﺑﺘﻌﺮﻳـﻒ‬
                                                 ‫هﺬﻩ اﻟﺪاﻟﺔ ﻓﻲ ﻣﻠﻒ ﺑﺮﻣﺠﺔ ‪:BAS‬‬

‫‪Function Hex(lNum As Long) As String‬‬
  ‫)‪Hex = VBA.Hex$(lNum‬‬
  ‫)"ا" ,"‪Hex = Replace(Hex, "A‬‬
  ‫)"ب" ,"‪Hex = Replace(Hex, "B‬‬
  ‫)"ت" ,"‪Hex = Replace(Hex, "C‬‬
  ‫)"ث" ,"‪Hex = Replace(Hex, "D‬‬
  ‫)"ج" ,"‪Hex = Replace(Hex, "E‬‬
  ‫)"ح" ,"‪Hex = Replace(Hex, "F‬‬
‫‪End Function‬‬

                                                ‫ﻳﻤﻜﻨﻚ اﺳﺘﺪﻋﺎﺋﻬﺎ ﺑﻨﻔﺲ اﻟﻄﺮﻳﻘﺔ:‬

‫‪Dim lCounter As Long‬‬

‫51 ‪For lCounter = 0 To‬‬
   ‫)‪Print Hex(lCounter‬‬
‫‪Next‬‬



                                                                 ‫اﻻهﺮام اﻟﻜﺎﺋﻨﻴﺔ‬
‫ﻋﻨﺪﻣﺎ ﺗﺼﺒﺢ ﻣﺒﺮﻣﺞ آﺎﺋﻨﻲ اﻟﺘﻮﺟﻪ، ﻓـﺎن ﻧﻈﺮﺗـﻚ اﻟـﻰ ﻋﻤﻠﻴـﺔ ﺑﻨـﺎء وﺗﺼـﻤﻴﻢ اﻟﺒﺮﻧـﺎﻣﺞ‬
‫ﺗﻨﺘﻄﻠﻖ ﻣﻦ ﻣﺤﻮر آﺎﺋﻨﺎﺗﻪ وﻟﻴﺲ اآـﻮادﻩ، ﻣﺠﻤﻮﻋـﺔ اﻟﻜﺎﺋﻨـﺎت اﻟﺘـﻲ ﺗﺼـﻤﻤﻬﺎ ﺗﺴـﻤﻰ‬
                                              ‫091‬


‫اﻻهﺮام اﻟﻜﺎﺋﻨﻴﺔ ‪ Object Hierarchies‬اﻟﺨﺎﺻﺔ ﺑﺒﺮﻧﺎﻣﺠﻚ. ﻓﻠﻮ ﺗﻨﻈﺮ اﻟﻰ ﻣﻌﻈﻢ اﻟﺒﺮاﻣﺞ‬
‫اﻟﺘﺠﺎرﻳﺔ آــ ‪ .... Microsoft PowerPoint ،Microsoft Excel ،Microsoft Word‬اﻟـﺦ او‬
‫ﺣﺘﻰ ﺗﻘﻨﻴﺎت اﺧﺮى آـ ‪ .... DirectX ،DAO ،ADO‬اﻟﺦ، ﺗﻼﺣﻆ ان ﻟﻜـﻞ ﻣﻨـﺘﺞ او ﻋﻨﺼـﺮ‬
                                ‫ﻣﻦ هﺆﻻء اهﺮام آﺎﺋﻨﻴﺔ ﺧﺎﺻﺔ ﺑﻪ ﻣﺮﺗﺒﻂ ﺑﻌﻀﻬﺎ ﺑﺒﻌﺾ.‬
‫ﺑﻨﺎء اهﺮاﻣﻚ اﻟﻜﺎﺋﻨﻴﺔ اﻟﺨﺎﺻﺔ ﺑﻚ اﻣﺮ ﻓﻲ ﻏﺎﻳﺔ اﻻهﻤﻴﺔ وآﻞ ﻣﺎ ﻳﻠﺰﻣﻚ هﻮ اﻟﺘﺮآﻴﺰ ﻓـﻲ‬
‫ﺗﺼﻤﻴﻢ اﻟﻬﺮم اﻟﻜﺎﺋﻨﻲ وﻟﻴﺲ ﻓﻲ اآﻮادﻩ، ﻓﺎﻟﺘﺼﻤﻴﻢ اﻟﺠﻴﺪ هﻮ اﻟﻌﺎﻣـﻞ اﻟـﺮﺋﻴﺲ ﻟﻨﺠـﺎح‬
‫هﺮﻣﻚ اﻟﻜﺎﺋﻨﻲ، اﻣﺎ اآﻮادﻩ ﻓﺘﺄﺗﻲ ﻓﻲ اﻟﻤﺮﺣﻠﺔ اﻟﺘﺎﻟﻴـﺔ. ﻣـﻊ ذﻟـﻚ، اﺳـﺎﻟﻴﺐ اﻟﺘﺼـﻤﻴﻢ‬
‫واﻋﺪاد اﻟﻤﺨﻄﻄﺎت اﻻوﻟﻴﺔ ﻻﻧﺸﺎء اﻟﻬﺮم اﻟﻜﺎﺋﻨﻲ ﺧﺎرج ﻧﻄﺎق اﻟﻜﺘﺎب، وﻟﻜﻦ ﺳـﺄﺟﻬﺰك‬
                ‫هﻨﺎ ﺑﻜﻞ ﻣﺎ ﺗﺤﺘﺎﺟﻪ ﻟﺒﻨﺎء اﻻهﺮام اﻟﻜﺎﺋﻨﻴﺔ وﺳﺄﺑﺪا ﺑﺎﻟﻌﻼﻗﺎت ﺑﻴﻦ اﻟﻔﺌﺎت.‬

                                                       ‫اﻟﻌﻼﻗﺎت ﺑﻴﻦ اﻟﻔﺌﺎت‬
‫ﻓﻲ ﻋﺎﻟﻢ اﻟﺒﺮﻣﺠﺔ آﺎﺋﻨﺔ اﻟﺘﻮﺟﻪ ‪ OOP‬ﻳﻮﺟﺪ ﻧﻮع ﻣﻦ اﻟﻌﻼﻗﺎت ﺗﺴـﻤﻰ "ﻳﺤﺘـﻮي ﻋﻠـﻰ‬
‫‪ "Has a‬وﻗﺪ ذآﺮﺗﻬﺎ ﻓﻲ ﻓﻘﺮة "اﻟﻮراﺛﺔ" ﻓﻲ هﺬا اﻟﻔﺼﻞ، اﻟﻬﺪف ﻣﻦ هـﺬﻩ اﻟﻌﻼﻗـﺔ هـﻮ‬
‫رﺑﻂ اﻟﻔﺌﺎت ﺑﻌﻀﻬﺎ ﺑﺒﻌﺾ ﺣﺘﻰ ﺗﺘﻤﻜﻦ ﻣﻦ ﺑﻨﺎء هﺮم آﺎﺋﻨﻲ. ﻃﺮﻳﻘﺔ اﻟﺮﺑﻂ ﺗﺘﻢ ﺑﺴﻬﻮﻟﺔ‬
‫ﺷﺪﻳﺪة، ﻓﻜﻞ ﻣﺎ ﻋﻠﻴﻚ اﻟﻘﻴﺎم ﺑﻪ هﻮ ﺗﻌﺮﻳـﻒ آـﺎﺋﻦ ﻣـﻦ ﻓﺌـﺔ اﺧـﺮى ﻓـﻲ داﺧـﻞ اﻟﻔﺌـﺔ‬
    ‫ﺣﺘﻰ ﺗﺼﻞ اﻟﻰ اﻋﻀﺎء اﻟﻔﺌﺔ اﻻﺧﺮى. ﻳﻮﺟﺪ ﻧﻮﻋﻴﻦ ﻣﻦ ﻋﻼﻗﺔ "ﻳﺤﺘﻮي ﻋﻠﻰ" هﻤﺎ:‬

                                                                  ‫ﻋﻼﻗﺔ 1 اﻟﻰ 1:‬
‫ﻋﻼﻗﺔ 1 اﻟﻰ 1 هﻲ ﻋﻼﻗﺔ ﺑﻴﻦ ﻓﺌﺔ س وﻓﺌﺔ ص ﺗﺮﺑﻄﻬﺎ آﺎﺋﻨـﺎت ﻣﻮﺟـﻮدة ﻓـﻲ اﻟﻔﺌـﺔ‬
‫س ﻟﺘﺼﻞ اﻟﻰ اﻋﻀﺎء اﻟﻔﺌﺔ ص، ﻓﻤﺜﻼ ﻟﻮ آﺎن ﻟـﺪﻳﻨﺎ اﻟﻔﺌـﺔ ‪ CCar‬واردﻧـﺎ رﺑﻄﻬـﺎ ﺑﺎﻟﻔﺌـﺔ‬
‫‪ CPerson‬ﺑﺤﻴﺚ ﺗﻤﺜﻞ ﻣﺎﻟﻚ اﻟﺴﻴﺎرة وﺳﺎﺋﻖ اﻟﺴﻴﺎرة ﻓﻘﺪ ﺗﻀﻴﻒ ﺧﺎﺻﺘﻴﻦ ‪objOwner‬‬
                                       ‫و ‪ objDriver‬ﻓﻲ اﻟﻔﺌﺔ ‪ CCar‬وﺗﻜﺘﺐ ﺷﻴﺌﺎ ﻣﺜﻞ:‬

‫اﻟﻔﺌﺔ ‪‘ CCar‬‬
‫‪Public objOwner As CPerson‬‬
‫‪Public objDriver As CPerson‬‬
‫‪Public sCarModel As String‬‬
                                           ‫191‬


            ‫وﺑﻬﺎ ﺗﻜﻮن ﻗﺪ آﻮﻧﺖ ﻋﻼﻗﺔ ﻓﻲ اﻟﻬﺮم اﻟﻜﺎﺋﻨﻲ اﻟﺒﺴﻴﻂ ﺟﺪا ﺷﻜﻞ 6-1.‬




                         ‫ﺷﻜﻞ 6-1: هﺮم آﺎﺋﻨﻲ ﺑﺴﻴﻂ ﻳﺒﻴﻦ اﻟﻌﻼﻗﺔ ﺑﻴﻦ آﺎﺋﻨﺎﺗﻪ.‬

‫ﻃﺒﻌﺎ اذا آـﺎن اﻟﻬـﺮم اﻟﻜـﺎﺋﻨﻲ ﻳﺤﺘـﻮي ﻋﻠـﻰ اآﺜـﺮ ﻣـﻦ 002 ﻓﺌـﺔ –ﻣﺜـﻞ ﻣﻜﺘﺒـﺔ ‪،MFC‬‬
‫ﻓﺴﻴﻜﻮن اﻟﺘﺼﻤﻴﻢ آﻤﺎ ﻓﻲ اﻟﺸﻜﻞ اﻟﺴﺎﺑﻖ اﻣـﺮ ﻓـﻲ ﻏﺎﻳـﺔ اﻻهﻤﻴـﺔ وﻳﺼـﺒﺢ ﺗﺮآﻴـﺰك‬
‫ﻋﻠﻰ اﻟﺘﺼﻤﻴﻢ اآﺜﺮ ﻣﻦ اﻧﺠﺎز اﻻآﻮاد. اﻣﺎ اذا اردت اﺳﺘﺨﺪم اﻟﻔﺌـﺎت ‪ CCar‬و ‪CPerson‬‬
                                                          ‫ﻓﻘﺪ ﺗﻜﺘﺐ ﺷﻴﺌﺎ ﻣﺜﻞ:‬

‫‪Dim Turki As New CPerson‬‬
‫‪Dim Abbas As New CPerson‬‬
‫‪Dim BMW As New CCar‬‬

‫”ﺗﺮآﻲ اﻟﻌﺴﻴﺮي“ = ‪Turki.sName‬‬
‫”ﻋﺒﺎس اﻟﺴﺮﻳﻊ“ = ‪Abbas.sName‬‬

‫…‬
‫…‬

‫”7 - ‪BMW.sCarModel = “BMW‬‬
‫‪Set BMW.objOwner = Turki‬‬
‫‪Set BMW.objDriver = Abbas‬‬

‫ﺑﻞ ﻳﻤﻜﻨـﻚ اﻟﻮﺻـﻮل اﻟـﻰ اﻋﻀـﺎء اﻟﻜﺎﺋﻨـﺎت ‪ objOwner‬و ‪ objDriver‬واﻧـﺖ ﻓـﻲ داﺧـﻞ‬
          ‫اﻟﻔﺌﺔ ‪ ،CCar‬ﻓﻘﺪ ﺗﻀﻴﻒ ﻃﺮﻳﻘﺔ اﻟﻰ اﻟﻔﺌﺔ ﻟﻄﺒﺎﻋﺔ اﺳﻢ اﻟﻤﺎﻟﻚ واﻟﺴﺎﺋﻖ:‬
                                                ‫291‬


‫ﺗﻌﺮﻳﻒ ﻃﺮﻳﻘﺔ ﻓﻲ اﻟﻔﺌﺔ ‪‘ CCar‬‬
‫)‪Public Sub PrintRelatedPeople ( frmForm As Form‬‬
        ‫‪ ” & Me.sCarModel‬اﻟﻤﻮدﻳﻞ:“ ‪frmForm.Print‬‬
        ‫‪ ” & Me.objOwner‬اﻟﻤﺎﻟﻚ:“ ‪frmForm.Print‬‬
        ‫‪ ” & Me. objDriver‬اﻟﺴﺎﺋﻖ:“ ‪frmForm.Print‬‬
‫‪End Sub‬‬

‫ﻓﻌﻼ، اﻟﺒﺮﻣﺠﺔ آﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ ‪ OOP‬ﺑﺮﻣﺠﺔ ﻣﻤﺘﻌﺔ ﻟﻠﻐﺎﻳﺔ واﻗﺮب اﻟـﻰ اﻟﻌـﺎﻟﻢ اﻟﺤﻘﻴﻘـﻲ‬
                                                 ‫ﻣﻦ اﻟﺒﺮﻣﺠﺔ اﻻﺟﺮاﺋﻴﺔ اﻟﻤﻌﻘﺪة.‬

                                                                  ‫ﻋﻼﻗﺔ 1 اﻟﻰ ن:‬
‫ﻗﺪ ﺗﻜﻮن هﻨﺎك اآﺜﺮ ﻣﻦ ﻋﻼﻗﺔ ﺑﻴﻦ ﻧﻔـﺲ اﻟﻜﺎﺋﻨـﺎت ﻟﺘﻤﺜـﻞ ﻋﻼﻗـﺔ اآﺜـﺮ ﺗﻌﻘﻴـﺪا ﺗﻌـﺮف‬
‫ﺑﻌﻼﻗﺔ 1 اﻟﻰ ن، ﺣﻴﺚ ﻳﺤﺘﻮي اﻟﻜﺎﺋﻦ ﻋﻠـﻰ ﻣﺠﻤﻮﻋـﺔ آﺎﺋﻨـﺎت ﻣـﻦ ﻧﻔـﺲ اﻟﻨـﻮع. ﻓﻠـﻮ‬
‫ﻋــﺪﻧﺎ اﻟــﻰ اﻟﻤﺜــﺎل اﻟﺴــﺎﺑﻖ، ﺳــﻨﻼﺣﻆ ان اﻟﺴــﻴﺎرة اﻟﻮاﺣــﺪة ‪ CCar‬ﻟﻬــﺎ ﻣﺎﻟــﻚ واﺣــﺪ‬
‫‪ objOwner‬و ﺳﺎﺋﻖ واﺣﺪ ‪ ،objDriver‬ﻧﺴـﺘﻄﻴﻊ ﺗﻄـﻮﻳﺮ آـﺎﺋﻦ اﻟﺴـﺎﺋﻖ ﺑﺤﻴـﺚ ﻳﻤﻜـﻦ‬
‫ﻟﻠﺴﻴﺎرة ان ﻳﻜﻮن ﻟﻬﺎ اآﺜﺮ ﻣﻦ ﺳﺎﺋﻖ –وﻟﺪ ﻧﻌﻤﺔ! ﻗـﺪ ﺗﺴـﺘﺨﺪم اﺳـﻠﻮب اﻟﻤﺼـﻔﻮﻓﺎت‬
                                  ‫ﻟﺘﻌﻴﺪ ﺗﻌﺮﻳﻒ اﻟﻜﺎﺋﻦ ‪ objDriver‬آﻤﺎ ﻓﻲ اﻟﻜﻮد اﻟﺘﺎﻟﻲ:‬

‫اﻟﻔﺌﺔ ‪‘ CCar‬‬
‫‪Private m_objDrivers (5) As CPerson‬‬

‫‪Public Property Get objDriver( iDriverNum As Integer ) As CPerson‬‬
        ‫) ‪Set objDriver = m_objDrivers ( iDriverNum‬‬
‫‪End Property‬‬

‫)‪Public Property Set objDriver( iDriverNum As Integer, ByVal objNewValue As CPerson‬‬
        ‫‪Set m_objDrivers ( iDriverNum ) = objNewValue‬‬
‫‪End Property‬‬

                                ‫ﺑﺎﻣﻜﺎﻧﻚ اﻟﻮﺻﻮل اﻟﻰ هﺬﻩ اﻟﺨﺎﺻﻴﺔ ﺑﻜﺘﺎﺑﺔ ﺷﻴﺌﺎ ﻣﺜﻞ:‬

‫‪Set‬‬   ‫‪BMW.objOwner = Turki‬‬
‫‪Set‬‬   ‫‪BMW.objDriver (0) = Abbas‬‬
‫‪Set‬‬   ‫‪BMW.objDriver (1) = Ahmed‬‬
‫‪Set‬‬   ‫‪BMW.objDriver (2) = Ali‬‬
‫…‬
                                             ‫391‬


‫…‬


‫ﻳﻌﺮف اﻟﻨﻮع اﻟﺴﺎﺑﻖ ﺑﺎﻧﻪ "ﻋﻼﻗﺔ 1 اﻟﻰ ن ﻣﺒﻨﻴﺔ ﻋﻠﻰ اﻟﻤﺼـﻔﻮﻓﺎت" 1 ‪Array based‬‬
‫‪ ،to many relationship‬وﻳﻮﺟﺪ ﻧﻮع اﺧﺮ –اﻓﻀﻠﻪ آﺜﻴﺮا- ﻳﻌﺮف "ﺑﻌﻼﻗﺔ 1 اﻟﻰ ن ﻣﺒﻨﻴـﺔ‬
‫ﻋﻠـﻰ اﻟﻤﺠﻤﻮﻋـﺎت" ‪ ،Array based 1 to many relationship‬ﺣﻴـﺚ ﺗﻜـﻮن اﻟﺨﺎﺻـﻴﺔ‬
                      ‫‪ objDriver‬ﻋﺒﺎرة ﻋﻦ ﻣﺠﻤﻮﻋﺔ ‪ Collection‬ﺑﺪﻻ ﻣﻦ ﻣﺼﻔﻮﻓﺔ:‬

‫اﻟﻔﺌﺔ ‪‘ CCar‬‬
‫‪Public objDrivers As New Collection‬‬

                           ‫ﺑﺎﻣﻜﺎﻧﻚ اﺿﺎﻓﺔ اﻟﻜﺎﺋﻨﺎت اﻟﻰ اﻟﺨﺎﺻﻴﺔ ‪ objDriver‬ﻣﺒﺎﺷﺮة:‬

‫‪BMW.objDrivers.Add Turki‬‬
‫‪BMW.objDrivers.Add Ali‬‬

‫او ﺣﺘﻰ اﻟﻮﺻﻮل اﻟﻰ آﺎﻓﺔ ﻋﻨﺎﺻﺮ اﻟﺨﺎﺻﻴﺔ ‪ objDriver‬ﺑﺎﺳﺘﺨﺪام ﺣﻠﻘﺔ ‪:For … Each‬‬

‫‪Dim objDriver As CPerson‬‬

‫‪For Each objDriver In BMW.objDrivers‬‬
   ‫‪Print objDriver.sName‬‬
‫‪Next‬‬

‫اﻟﻤﺸﻜﻠﺔ ﻓﻲ اﻟﻌﻼﻗﺎت اﻟﻤﺒﻨﻴﺔ ﻋﻠﻰ اﻟﻤﺠﻤﻮﻋـﺎت ﺗﻈﻬـﺮ ﻋﻨـﺪﻣﺎ ﻧﻌﻠـﻢ ان اﻟﻤﺠﻤﻮﻋـﺔ‬
‫)اﻟﺨﺎﺻﻴﺔ( ‪ objDriver‬ﻳﻤﻜﻨﻬﺎ ان ﺗﺤﻤﻞ أي ﻧﻮع ﻣﻦ اﻟﻘﻴﻢ، ﻓﻬﺬا اﻟﻜـﻮد ﺳـﻴﺘﻢ ﺗﻨﻔﻴـﺬﻩ‬
                                                                ‫ﺑﺸﻜﻞ ﺻﺤﻴﺢ:‬

‫‪Dim BMW As New CCar‬‬
‫‪Dim Mercury As New CCar‬‬

‫…‬
‫…‬

‫‪BMW.objDrivers.Add Mercuty‬‬            ‫ﺳﺎﺋﻖ اﻟﺴﻴﺎرة هﻲ ﺳﻴﺎرة اﺧﺮى! ‘‬
                                                ‫491‬


‫واﻟﺤﻞ ﻳﺘﻢ ﺑﺎﻧﺸﺎء ﻓﺌﺔ ﺧﺎﺻـﺔ ﺗﺴـﻤﻰ ﻓﺌـﺔ اﻟﻤﺠﻤﻮﻋـﺔ ‪CPersons Collection Class‬‬
‫ﻟﻬــﺎ ﻃــﺮق وﺧﺼــﺎﺋﺺ ﻗﻴﺎﺳــﻴﺔ ﻳﺘﺒﻌﻬــﺎ آــﻞ اﻟﻤﺒــﺮﻣﺠﻴﻦ وﺟﻤﻴــﻊ اﻟﻤﻜﺘﺒــﺎت واﻟﻜﺎﺋﻨــﺎت‬
‫اﻟﻤﺘﻮﻓﺮة ﻓﻲ ‪ Visual Basic‬و ﻟﻐـﺎت اﻟﺒﺮﻣﺠـﺔ اﻻﺧـﺮى اﻟﻤﺘﻮاﻓﻘـﺔ ﻣـﻊ ‪ COM‬آﻤـﺎ ﻓـﻲ‬
                                                                        ‫اﻟﻔﻘﺮة اﻟﺘﺎﻟﻴﺔ.‬

                               ‫ﻓﺌﺎت اﻟﻤﺠﻤﻮﻋﺎت ‪Collection Classes‬‬
‫ﻓﺌﺎت اﻟﻤﺠﻤﻮﻋﺎت ﻣﺎ هﻲ اﻻ ﻓﺌـﺎت ﻋﺎدﻳـﺔ ﻟﻜـﻦ ﻟﻬـﺎ ﺧﺼـﺎﺋﺺ وﻃـﺮق ﻗﻴﺎﺳـﻴﺔ ﻋﻠﻴـﻚ‬
‫اﺗﺒﺎﻋﻬﺎ ﺣﺘﻰ ﻳﻄﻠﻖ ﻋﻠﻰ اﻟﻔﺌﺔ اﻟﻠﻘﺐ "ﻓﺌﺔ ﻣﺠﻤﻮﻋﺔ" ‪ ،Collection Class‬وان اﺻـﺮرت‬
‫ﻋﻠﻰ ﻋﺪم اﺗﺒﺎع هﺬﻩ اﻟﻤﻮاﺻﻔﺎت اﻟﻘﻴﺎﺳﻴﺔ ﻟﻠﻔﺌﺔ، ﻓﺎرﺟﻮ ان ﺗﻌﻮد اﻟـﻰ رﺷـﺪك وﺗﻠـﻴﻦ‬
‫ﻋﻨﺎدك ﻗﻠﻴﻼ، ﻓﺠﻤﻴﻊ اﻟﻔﺌﺎت اﻟﻤﻨﺠﺰة ﺑﻠﻐﺎت اﻟﺒﺮﻣﺠﺔ اﻟﻤﺨﺘﻠﻔﺔ واﻟﺪاﻋﻤﺔ ﻟﺘﻘﻨﻴـﺔ ‪COM‬‬
                                        ‫ﺗﺘﺒﻊ هﺬا اﻻﺳﻠﻮب ﺑﻤﺎ ﻓﻴﻬﻢ ‪.Visual Basic‬‬
‫اول ﻗﺎﻋﺪة ﻋﻠﻴـﻚ ﻣﻌﺮﻓﺘﻬـﺎ هـﻲ ان ﻓﺌـﺔ اﻟﻤﺠﻤﻮﻋـﺔ ﺗﻤﺜـﻞ ﻣﺠﻤﻮﻋـﺔ ﻟﻜﺎﺋﻨـﺎت ﻣﻌﻴﻨـﺔ‬
‫وﻧﻤﻴﻴﺰهﺎ ﻋﻦ ﻓﺌﺔ اﻟﻜﺎﺋﻨﺎت ﺑﺎﻟﺤﺮف "‪ ،"s‬ﻓﺎﻟﻔﺌﺔ ‪ CPerson‬ﻳﻤﻜـﻦ ان ﺗﻜـﻮن ﺗﺎﺑﻌـﺔ ﻟﻔﺌـﺔ‬
                                                      ‫ﻣﺠﻤﻮﻋﺔ ﺑﺎﺳﻢ ‪.CPersons‬‬
‫اﻣﺎ ﻟﺒﻨﺎء اﻟﻤﺠﻤﻮﻋﺔ ‪ CPersons‬اﻧﺸﺊ ﻓﺌﺔ ﺟﺪﻳﺪة وﺳﻤﻬﺎ ‪ CPerons‬واآﺘﺐ هﺬا اﻟﻜﻮد‬
                               ‫اﻟﻤﺤﺎآﻲ ﻟﻄﺮق وﺧﺼﺎﺋﺺ اﻟﻤﺠﻤﻮﻋﺎت ‪:Collections‬‬

‫ﻓﺌﺔ اﻟﻤﺠﻤﻮﻋﺔ ‪‘ CPersons‬‬
‫‪Private m_Col As New Collection‬‬

‫_ ,‪Public Sub Add(objNewItem As CPerson, Optional vKey As Variant‬‬
‫)‪Optional vBefore As Variant, Optional vAfter As Variant‬‬
        ‫‪m_Col.Add objNewItem, vKey‬‬
‫‪End Sub‬‬

‫)‪Public Sub Remove(vIndexKey As Variant‬‬
        ‫‪m_Col.Remove vIndexKey‬‬
‫‪End Sub‬‬

‫‪Public Property Get Count() As Long‬‬
        ‫‪Count = m_Col.Count‬‬
‫‪End Property‬‬

‫‪Public Property Get Item(vIndexKey As Variant) As CPerson‬‬
        ‫)‪Set Item = m_Col(vIndexKey‬‬
                                           ‫591‬


‫‪End Property‬‬

 ‫ﺗﺴﺘﻄﻴﻊ اﺳﺘﺨﺪام اﻻﺿﺎﻓﺔ ‪ Add-Ins‬اﻟﻤﺴﻤﺎة ‪Class Builder Utility‬‬        ‫ﻣﻼﺣﻈﺔ:‬
 ‫ﻟﺘﺴﻬﻴﻞ ﻋﻤﻠﻴﺔ آﺘﺎﺑﺔ ﻃﺮق وﺧﺼﺎﺋﺺ ﻓﺌﺔ اﻟﻤﺠﻤﻮﻋﺔ ﺗﻠﻘﺎﺋﻴﺎ وﻣﻦ ﺛـﻢ‬
                                                ‫ﺗﻌﺪﻳﻠﻬﺎ ﺑﻨﻔﺴﻚ.‬

‫ﺑﺎﻣﻜﺎﻧﻚ اﻻﻧﺘﻘﺎل اﻟﻰ اﻟﻔﺌﺔ ‪ CCar‬وﺗﻐﻴﻴﺮ ﻧﻮع اﻟﻜﺎﺋﻦ ‪ objDrivers‬ﻣـﻦ ‪ Collection‬اﻟـﻰ‬
                                                                    ‫‪:CPersons‬‬

‫‪Public objDrivers As New CPersons‬‬

 ‫ـ‬     ‫ـ‬    ‫ـ‬
‫واﻻن اﺳـﺘﺨﺪم اﻟﻔﺌـﺎت ‪ CCar‬و ‪ CPerson‬ﺑـﻨﻔﺲ اﻟﻄﺮﻳﻘـﺔ اﻟﺴـﺎﺑﻘﺔ وآـﺄن ﺷـﻴﺌﺎ ﻟـﻢ‬
                    ‫ـ‬     ‫ـ‬          ‫ـ‬                   ‫ـ‬         ‫ـ‬
                                                                     ‫ﻳﺤﺪث:‬

‫‪Dim BMW As New CCar‬‬
‫‪Dim Driver1 As New CPerson‬‬
‫‪Dim Driver2 As New CPerson‬‬
‫…‬
‫…‬

‫”ﻣﺤﻤﺪ“ = ‪Driver1.sName‬‬
‫”ﻋﺒﺪاﷲ“ = ‪Driver2.sName‬‬
‫…‬
‫…‬

‫1‪BMW.objDrivers.Add Driver‬‬
‫2‪BMW.objDrivers.Add Driver‬‬

                                            ‫ﺿﺮورة اﻻﻟﺘﺰام ﺑﺎﻟﻤﻌﺎﻳﻴﺮ اﻟﻘﻴﺎﺳﻴﺔ:‬
‫ﻓﻲ ﺑﺪاﻳﺔ اﻟﻔﻘﺮة اآﺪت ﻋﻠﻰ ﻣﺴﺄﻟﺔ اﻻﻟﺘﺰام ﺑﺎﻟﻤﻮاﺻﻔﺎت واﻟﻤﻌـﺎﻳﻴﺮ اﻟﻘﻴﺎﺳـﻴﺔ ﻟﻔﺌـﺎت‬
 ‫ـ‬
‫اﻟﻤﺠﻤﻮﻋـﺎت، وﻗـﺪ ﻗﻤﻨـﺎ ﺑﻌﻤﻠﻴـﺔ ﻣﺤﺎآـﺎة ﻟﻤﻌﻈـﻢ ﻃـﺮق وﺧﺼـﺎﺋﺺ اﻟﻤﺠﻤﻮﻋـﺎت آﻤـﺎ‬
‫ﻳﻨﺒﻐﻲ، وﻟﻜﻦ ﺑﻘﻴﺖ ﻧﻘﻄﺘﻴﻦ ﺑﻮدي ﺗﻮﺿـﻴﺤﻬﺎ، اﻻوﻟـﻰ ﺗﺘﻌﻠـﻖ ﺑﺎﻟﺨﺎﺻـﻴﺔ ‪ Item‬اﻟﺘﺎﺑﻌـﺔ‬
‫ﻟﻠﻤﺠﻤﻮﻋــﺔ ‪ ،CPersons‬ﻓﻴﺠــﺐ ان ﺗﻜــﻮن اﻟﺨﺎﺻــﻴﺔ اﻻﻓﺘﺮاﺿــﻴﺔ ‪Default Property‬‬
                               ‫ﻟﻠﻤﺠﻤﻮﻋﺔ ‪ CPersons‬ﺑﺤﺚ ﻳﻤﻜﻦ ﻟﻠﻤﺒﺮﻣﺞ ﺗﺠﺎهﻠﻬﺎ:‬
                                              ‫691‬


‫‪Print BMW.objDrivers.Item(1).sName‬‬
‫‪Print BMW.objDrivers(2).sName‬‬

‫ﺑﺎﻣﻜﺎﻧﻚ ﻋﻤﻞ ذﻟﻚ ﻋﻦ ﻃﺮﻳﻖ ﺻﻨﺪوق اﻟﺤﻮار ‪ Procedure Attributes‬آﻤﺎ ذآـﺮت ﻓـﻲ‬
                                 ‫اﻟﻔﺼﻞ اﻟﺴﺎﺑﻖ "اﻟﺒﺮﻣﺠﺔ آﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ ‪."OOP‬‬

‫اﻣﺎ اﻟﻨﻘﻄﺔ اﻟﺜﺎﻧﻴﺔ اﻟﺘﻲ اود ان اذآﺮهﺎ هﻲ ﻗﺎﺑﻠﻴﺔ اﺳﺘﺨﺪام اﻟﺤﻠﻘﺔ ‪ For … Each‬ﻣـﻊ‬
                                   ‫اﻟﻤﺠﻤﻮﻋﺔ ‪ ،CPersons‬ﻓﻠﻮ آﺘﺒﺖ هﺬا اﻟﻜﻮد:‬

‫‪Dim objDriver As CPerson‬‬

‫‪For Each objDriver In BMW.objDrivers‬‬
   ‫‪Print objDriver.sName‬‬
‫‪Next‬‬

‫ﺳﻴﻈﻬﺮ ﻟﻚ ‪ Visual Basic‬رﺳﺎﻟﺔ ﺧﻄﺄ، ﻻن اﻟﺤﻠﻘﺔ ‪ For … Each‬ﻟﻴﺴﺖ ﻣﺪﻋﻮﻣﺔ ﻓﻲ‬
‫ﻣﺠﻤﻮﻋﺘﻨــﺎ اﻟﺠﺪﻳــﺪ ‪ ،CPersons‬ﻟــﺬﻟﻚ ﻋﻠﻴــﻚ آﺘﺎﺑــﺔ اﻟﻜــﻮد اﻟﺘــﺎﻟﻲ ﻓــﻲ اﻟﻤﺠﻤﻮﻋــﺔ‬
                                                                         ‫‪:CPersons‬‬

‫‪Public Property Get NewEnum() As IUnknown‬‬
        ‫]‪Set NewEnum = m_Col.[_NewEnum‬‬
‫‪End Property‬‬

‫وآﺘﺎﺑﺔ اﻟﻘﻴﻤﺔ 4- ﻓﻲ اﻟﺨﺎﻧﺔ ‪ Procedure ID‬اﻟﺘﺎﺑﻌﺔ ﻟﻼﺟﺮاء ‪ NewEnum‬ﻓﻲ ﺻـﻨﺪوق‬
‫اﻟﺤـﻮار ‪ Procedure Attributes‬وﺗﺤﺪﻳـﺪ اﻻﺧﺘﻴـﺎر ‪ Hide this member‬ﺷـﻜﻞ 6-2،‬
    ‫وﺗﻜﻮن ﺑﺬﻟﻚ ﻗﺎدر ﻋﻠﻰ اﺳﺘﺨﺪام اﻟﺤﻠﻘﺔ ‪ For … Each‬ﻣﻊ اﻟﻤﺠﻤﻮﻋﺔ ‪.CPersons‬‬
                                               ‫791‬




                                   ‫ﺷﻜﻞ 6-2: ﺗﻌﺪﻳﻞ ﻣﻮاﺻﻔﺎت اﻻﺟﺮاء ‪.NewEnum‬‬

 ‫اﺳﺘﻴﻌﺎب اﻟﺨﻄﻮات اﻟﺴﺎﺑﻘﺔ ﺧـﺎرج ﻧﻄـﺎق اﻟﻜﺘـﺎب، ﻻﻧـﻪ ﻳﺘﻄﻠـﺐ ﻓﻬـﻢ‬           ‫ﻣﻼﺣﻈﺔ:‬
 ‫اﻟﺒﻨﻴﺔ اﻟﺘﺮآﻴﺒﺎت ﻟﻤﻜﻮﻧﺎت ‪ COM‬اﻟﺘﺎﺑﻌﺔ ﻟـ ‪ OLE Automation‬واﻟﺨﺎﺻﺔ‬
 ‫ﺑﻮاﺟﻬـــﺎت اﻟﻤﻜﻮﻧـــﺎت آﺎﻟﻮاﺟﻬـــﺔ ‪ IUnknown‬او ﺑﺎﻟﺘﺤﺪﻳـــﺪ اﻟﻮاﺟﻬـــﺔ‬
         ‫ـ‬                  ‫ـ‬            ‫ـ‬
 ‫‪ .IEnumVariant‬اذا اردت ﻣﺰﻳ ـﺪ ﻣــﻦ اﻟﺘﻔﺎﺻ ـﻴﻞ اﻟﻤﺘﻘﺪﻣــﺔ ﺣ ـﻮل هــﺬا‬
                                               ‫اﻟﻤﻮﺿﻮع اﻧﺼﺤﻚ ﺑﻜﺘﺎب:‬
 ‫6 ‪Advanced Visual Basic‬‬
 ‫‪Power Techniques for Everyday Program‬‬
 ‫‪By: Matthew Curland‬‬
 ‫8-21707-102-0 :‪ISBN‬‬

‫اﺧﻴــﺮا، اذا اردت اﻋــﺎدة رﺳــﻢ اﻟﻬــﺮم اﻟﻜــﺎﺋﻨﻲ ‪ CPersons ،CPerson‬و ‪ CCar‬ﻓﻴﻔﻀــﻞ‬
‫اﺳﺘﺨﺪام ﻟﻮن ﻳﻤﻴﺰ ﻓﺌﺎت اﻟﻤﺠﻤﻮﻋﺎت ﻋﻦ اﻟﻔﺌﺎت اﻟﻌﺎدي ﺷـﻜﻞ 6-3 ﻓﻬـﻮ اﻻﺳـﻠﻮب‬
                      ‫اﻟﻤﺘﺒﻊ ﻓﻲ ﻣﻠﻔﺎت اﻟﺘﻌﻠﻴﻤﺎت وﻣﻮاﻗﻊ اﻻﻧﺘﺮﻧﺖ –اﻟﺘﻲ رأﻳﺘﻬﺎ.‬
                                            ‫891‬




                      ‫ﺷﻜﻞ 6-3: اﻟﻬﺮم اﻟﻜﺎﺋﻨﻲ ﺑﻌﺪ اﺿﺎﻓﺔ اﻟﻤﺠﻤﻮﻋﺔ ‪.CPersons‬‬




‫ﺑﻬﺬا اآﻮن ﻗﺪ اﻧﺘﻬﻴﺖ ﻣﻦ ﺗﺸﻴﻴﺪ ﺑﻨﻴﺔ اﺳﺎﺳﻴﺔ ﻟﺘﻜﻮن ﻣﺒـﺮﻣﺞ ‪ Visual Basic‬ﺣﻘﻴﻘـﻲ‬
‫ﺑﻌﺪﻣﺎ ﺗﻄﺮﻗﺖ اﻟﻰ اﻟﻤﺒﺎدئ واﻻﺳﺎﺳﻴﺎت اﻟﺘـﻲ ﻻﺑـﺪ ﻋﻠـﻰ آـﻞ ﻣﺒـﺮﻣﺞ ‪Visual Basic‬‬
       ‫ـ‬     ‫ـ‬       ‫ـ‬
‫ﻣـﻦ ﻣﻌﺮﻓﺘﻬـﺎ واﺗﻘﺎﻧﻬـﺎ ﻟﻼﺑﺤـﺎر ﻓـﻲ ﺑﺮﻣﺠـﺔ ‪ .Visual Basic‬وهـﺬﻩ ﻧﻬﺎﻳـﺔ اﻟﺠـﺰء اﻻول‬
                                        ‫ـ‬      ‫ـ ـ‬         ‫ـ‬         ‫ـ‬        ‫ـ‬
‫"اﻻﺳﺎﺳﻴﺎت" ﻣﻦ هﺬا اﻟﻜﺘﺎب، واﻻن ﺑﺎﻣﻜﺎﻧﻚ ﺗﻌﻠﻴﻢ ﻧﻔﺴﻚ ذاﺗﻴﺎ اﻣـﺎ ﺑﺎﻟﺤﺼـﻮل ﻋﻠـﻰ‬
‫آﺘﺐ ﻣﺘﺨﺼﺼﺔ ﻓﻲ ﻣﺠﺎل ﻣﻌﻴﻦ، او ﻗﺮاءة ﻣﻘـﺎﻻت ﻣﺘﻘﺪﻣـﺔ، او ﺣﺘـﻰ اﻻﺳـﺘﻤﺮار ﻓـﻲ‬
                   ‫ﻗﺮاءة هﺬا اﻟﻜﺘﺎب ان آﺎن اﺳﻠﻮب اﻟﻤﺆﻟﻒ ﻟﻴﺲ ﺳﻴﺌﺎ وﻣﻨﺎﺳﺒﺎ ﻟﻚ.‬

				
DOCUMENT INFO
Shared By:
Stats:
views:323
posted:1/13/2011
language:Arabic
pages:214
Description: كتاب رائع يعطي مبادئ البرمجة كائنية التوجه ويقودك نحو الإبداع في البرمجة