‫ﺑﺮﻣﺠﺔ اﻃﺎر ﻋﻤﻞ ‪ .NET‬ﺑﺎﺳﺘﺨﺪام‬

‫‪Visual Basic .NET‬‬

‫-- ﺗﺮآﻲ اﻟﻌﺴﻴﺮي‬

‫ﻨﺴﺨﺔ ﻋﺭﺽ ﻤﻥ ﺍﻟﻤﺭﺍﺠﻌﺔ ﻗﺒل ﺍﻻﺨﻴﺭﺓ ﻤﻥ ﺍﻟﻁﺒﻌﺔ ﺍﻻﻭﻟﻰ ﻟﻠﻜﺘﺎﺏ.‬
‫ﻤﻼﺤﻅﺔ: ﺍﻻﺨﻁﺎﺀ ﻏﻴﺭ ﻤﻨﻘﺤﺔ .‬
‫ﺑﺴﻢ اﷲ اﻟﺮﺣﻤﻦ اﻟﺮﺣﻴﻢ‬

‫)) ﺳﺒ َﺎ َ َ َﺎ ِﻠ َ َ َﺎ ِ ﱠﺎ َﺎ‬
‫ُ ْﺤ ﻧﻚ ﻟ ﻋ ْﻢ ﻟﻨ إﻟ ﻣ‬
‫َ ﱠﻤ َ َﺎ ِ ﱠ َ َﻧ َ اﻟ َ ِﻴﻢ اﻟ َ ِﻴﻢ‬
‫ﻋﻠ ْﺘﻨ إﻧﻚ أ ْﺖ ْﻌﻠ ُ ْﺤﻜ ُ‬

‫((‬
‫اهﺪاء‬
‫اﻟﺠﻤﺎل ﻓﻲ اﻟﺤﻴﺎة ﺷﺊ ﻳﺠﺒﺮ اﻟﻔﺆاد‬
‫ﻋﻠﻰ ذآﺮﻩ ﻓﻲ آﻞ ﻟﺤﻈﺔ ﻣﻦ ﻟﺤﻈﺎت ﺧﻔﻘﺎﻧﻪ ...‬
‫وان ﻟﻢ ﺗﻜﻮﻧﻲ ﻣﻦ اﻟﺠﻤﺎل ﻓﻲ اﻟﺤﻴﺎة،‬
‫ﻓﺤﺴﺒﻲ ان اﻟﺠﻤﺎل ﻗﺪ ﻧﺒﺾ اﻟﻰ اﻟﺤﻴﺎة ﻣﻨﻚ ...‬
‫اﻣﻲ اﻟﺤﺒﻴﺒﺔ،‬
‫اهﺪﻳﻚ هﺬا اﻟﻜﺘﺎب ...‬

‫اﺑﻨﻚ اﻟﻤﺨﻠﺺ‬
‫ﺑﺮﻣﺠﺔ اﻃﺎر ﻋﻤﻞ ‪.NET‬‬
‫ﺑﺎﺳﺘﺨﺪام ‪Visual Basic .NET‬‬
‫اﻟﻄﺒﻌﺔ اﻻوﻟﻰ 3002‬
‫‪S‬‬

‫ﺤﻘﻭﻕ ﻜﺘﺎﺏ ﺒﺭﻤﺠﺔ ﺍﻁـﺎﺭ ﻋﻤـل ‪ .NET‬ﺒﺎﺴـﺘﺨﺩﺍﻡ ‪ Visual Basic .NET‬ﻤﺤﻔﻭﻅـﺔ‬
‫ﻟﻠﻤﺅﻟﻑ، ﻭﻻ ﻴﺤﻕ ﻷﻱ ﺸﺨﺹ ﺍﻭ ﺠﻬﺔ ﺭﺴﻤﻴﺔ ﻤﻥ ﺍﻋﺎﺩﺓ ﻨﺸﺭ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﺍﻭ ﺠـﺯﺀ ﻤﻨـﻪ ﺒـﺄﻱ‬

‫ﻭﺴﻴﻠﺔ ﺩﻭﻥ ﺍﻻﺫﻥ ﺍﻟﺨﻁﻲ ﻤﻥ ﺍﻟﻤﺅﻟﻑ.‬
‫‪S‬‬

‫ﺍﺴﻤﺎﺀ ﺍﻟﺒﺭﺍﻤﺞ ﺍﻭ ﺍﻟﺘﻘﻨﻴـﺎﺕ ﺍﻭ ﺍﻟﺸـﺭﻜﺎﺕ )ﻜــ ‪،ADO .NET ،Visual Basic .NET‬‬
‫‪.... Microsoft‬ﺍﻟﺦ( ﻫﻲ ﻋﻼﻤﺎﺕ ﺘﺠﺎﺭﻴﺔ ﻤﺴﺠﻠﺔ ﻻﺼﺤﺎﺒﻬﺎ، ﻭﺍﻟﻤﺅﻟﻑ ﻴﺤﺘﺭﻡ ﻫﺫﻩ ﺍﻟﻌﻼﻤـﺎﺕ‬
‫ﻭﻴﻘﺭ ﺒﻬﺎ ﻟﻤﺎﻟﻴﻜﻬﺎ ﺴﻭﺍﺀ ﻜﺎﻨﻭﺍ ﺍﻓﺭﺍﺩ ﺍﻭ ﺸﺭﻜﺎﺕ ﺍﻭ ﺍﻱ ﺠﻬﺎﺕ ﺘﻨﻅﻴﻤﻴﺔ ﺍﺨﺭﻯ، ﻭﻟـﻡ ﻴـﺘﻡ ﺫﻜﺭﻫـﺎ‬
‫ﻟﻼﺨﺘﺼﺎﺭ.‬

‫‪S‬‬

‫ﺍﺴﻤﺎﺀ ﺍﻻﺸﺨﺎﺹ ﺍﻭ ﺍﻟﺸﺭﻜﺎﺕ ﻭﺍﻟﻤﺫﻜﻭﺭﺓ ﻓﻲ ﺍﻤﺜﻠﺔ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻫﻲ ﺍﺴﻤﺎﺀ ﻭﻫﻤﻴـﺔ ﻭﻻ ﻴﻘﺼـﺩ‬
‫ﺒﻬﺎ ﺘﺤﺩﻴﺩ ﻫﻭﻴﺔ ﺍﺸﺨﺎﺹ ﺍﻭ ﺠﻬﺎﺕ ﻤﻌﻴﻨﺔ.‬

‫‪S‬‬

‫ﺘﻡ ﺍﺨﺘﺒﺎﺭ ﺍﻟﻤﺎﺩﺓ ﺍﻟﻌﻠﻤﻴﺔ ﻓﻲ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻭﺍﻟﺘﺤﻘـﻕ ﻤﻨﻬـﺎ ﻭﻤﺭﺍﺠﻌﺘﻬـﺎ، ﺍﻻ ﺍﻥ ﺍﻟﻤﺅﻟـﻑ ﻏﻴـﺭ‬
‫ﻤﺴﺅﻭل ﺒﺎﻱ ﺸﻜل ﻤﻥ ﺍﻻﺸﻜﺎل ﻋﻥ ﺍﻻﻀﺭﺍﺭ ﺍﻟﻨﺎﺘﺠﺔ ﻤﻥ ﺘﻁﺒﻴﻕ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻓﻲ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ.‬

‫‪S‬‬

‫ﺠﻤﻴﻊ ﺍﻻﺭﺍﺀ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﺘﻌﺒﺭ ﻋﻥ ﺭﺃﻱ ﺍﻟﻤﺅﻟﻑ ﺍﻟﺸﺨﺼﻲ ﺤﺘـﻰ ﻟـﻭ ﻟـﻡ ﺘﻭﺜـﻕ‬

‫ﺒﺎﻤﺜﻠﺔ ﺍﻭ ﺍﺩﻟﺔ ﺤﺴﻴﺔ.‬
‫اﻟﻤﺤﺘﻮﻳﺎت‬
‫ﺘﻤﻬﻴﺩ‬
‫ﺘﻘﺩﻴﻡ‬

‫ﺍﻟﻤﻘﺩﻤﺔ‬
‫ﻟﻤﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ؟‬
‫ﻤﺎﺫﺍ ﻋﻥ ﻤﺒﺭﻤﺠﻲ 6‪ Visual Basic 1Î‬؟‬

‫ﺍﻟﻤﺼﻁﻠﺤﺎﺕ ﺘﻌﺭﻴﺏ ﺍﻡ ﺘﻌﺫﻴﺏ؟‬
‫ﻤﺎﺫﺍ ﻴﻘﺩﻡ ﻟﻙ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ؟‬

‫ﺍﻟﻘﺭﺹ ﺍﻟﻤﺩﻤﺞ ‪CD-ROM‬‬
‫ﺼﻔﺤﺔ ﺍﻟﻜﺘﺎﺏ ﻋﻠﻰ ﺍﻻﻨﺘﺭﻨﺕ‬
‫ﺍﻻﺨﻁﺎﺀ ) ﻫﺎﻡ ﺠﺩﺍ(‬
‫ﻜﻠﻤﺔ ﺍﺨﻴﺭﺓ‬
‫اﻟﺠﺰء اﻻول: اﻻﺳﺎﺳﻴﺎت‬
‫ﺍﻟﻔﺼل ﺍﻻﻭل: ﺘﻌﺭﻑ ﻋﻠﻰ ‪Visual Basic .NET‬‬
‫ﺍﻟﺤﻴﺎﺓ ﻗﺒل ‪.NET‬‬

‫ﺍﻟﺒﺭﻤﺠﺔ ﺘﺤﺕ ‪DOS‬‬
‫ﺍﻻﻨﺘﻘﺎل ﺍﻟﻰ ‪Windows‬‬

‫ﺍﻟﺤﻠﻡ ﺍﺼﺒﺢ ﺤﻘﻴﻘﺔ ﻤﻊ ‪COM‬‬
‫ﺘﺤﺩﻴﺎﺕ ﺍﻻﻨﺘﺭﻨﺕ‬

‫ﻋﺸﺭﺍﺕ ﺍﻟﺘﻘﻨﻴﺎﺕ ﻻﺩﺍﺀ ﺍﻟﻭﻅﺎﺌﻑ‬

‫ﺍﻟﺤﻴﺎﺓ ﺒﻌﺩ ‪.NET‬‬

‫ﺍﻻﺴﺘﻘﻼﻟﻴﺔ ﻋﻥ ﻤﻨﺼﺎﺕ ﺍﻟﻌﻤل‬
‫‪ .NET‬ﻨﺴﺨﺔ ﻤﺤﺴﻨﺔ ﻤﻥ ‪COM‬‬

‫ﺘﻜﺎﻤل ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ‬

‫ﺨﺩﻤﺎﺕ ﻭﻴﺏ ﻫﻲ ﻤﺴﺘﻘﺒل ﺍﻻﻨﺘﺭﻨﺕ1‬
‫ﻤﺎﺫﺍ ﻋﻥ ﺍﻟﻤﺒﺭﻤﺞ ﺍﻟﻌﺭﺒﻲ؟‬

‫ﻤﺤﺘﻭﻴﺎﺕ ﺍﻁﺎﺭ ﺍﻟﻌﻤل ‪.NET Framework‬‬
‫ﺍﻟﺘﺭﺠﻤﺔ ﻋﻠﻰ ﺍﻟﻔﻭﺭ ‪JIT‬‬

‫ﺍﻟﻤﺠﻤﻌﺎﺕ ‪Assemblies‬‬

‫ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ ‪Visual Studio .NET‬‬
‫ﻨﻭﺍﻓﺫ ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ‬
‫ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﺭﺌﻴﺴﺔ‬
‫ﺍﺸﺭﻁﺔ ﺍﻻﺩﻭﺍﺕ‬

‫ﻜﺘﺎﺒﺔ ﺒﺭﻨﺎﻤﺠﻙ ﺍﻻﻭل‬

‫ﺍﻟﺤﻠﻭل ﻭﺍﻟﻤﺸﺎﺭﻴﻊ‬

‫ﺍﻨﻭﺍﻉ ﺍﻟﻤﺸﺎﺭﻴﻊ‬

‫ﺒﻨﺎﺀ ﺒﺭﻨﺎﻤﺠﻙ ﺍﻻﻭل‬

‫ﺍﺴﺘﺨﺩﺍﻡ ‪ArabicConsole‬‬

‫ﺍﻟﺘﺭﺠﻤﺔ ﻭﺍﻟﺘﻭﺯﻴﻊ‬
‫ﺍﻟﻔﺼل ﺍﻟﺜﺎﻨﻲ: ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ‬

‫ﺍﻟﻭﺤﺩﺍﺕ ﺍﻟﺒﺭﻤﺠﻴﺔ ‪Modules‬‬
‫ﺍﻻﺠﺭﺍﺀ ‪Sub Main‬‬
‫ﺍﻻﺠﺭﺍﺀ ‪Sub New‬‬

‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻭﺍﻟﺜﻭﺍﺒﺕ‬
‫ﺍﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ‬

‫ﻗﺎﺒﻠﻴﺔ ﺍﻟﺭﺅﻴﺔ ﻭﻋﻤﺭ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ‬

‫ﺍﻨﻭﺍﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ‬

‫ﺍﻟﺜﻭﺍﺒﺕ‬

‫ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻭﺍﻟﻤﺼﻔﻭﻓﺎﺕ‬
‫ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻤﻥ ﻨﻭﻉ ‪Enum‬‬
‫ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻤﻥ ﻨﻭﻉ ‪Structure‬‬
‫ﺍﻟﻤﺼﻔﻭﻓﺎﺕ‬

‫ﺍﻻﺠﺭﺍﺀﺍﺕ ﻭﺍﻟﺩﻭﺍل‬

‫ﺍﻻﺭﺴﺎل ﺒﺎﻟﻤﺭﺠﻊ ﺍﻭ ﺍﻟﻘﻴﻤﺔ‬

‫ﺘﺨﺼﻴﺹ ﺍﻟﻭﺴﻴﻁﺎﺕ ﺍﻟﻤﺭﺴﻠﺔ‬

‫ﺘﺠﺎﻭﺯ ﺍﻟﺤﺩﻭﺩ ﻤﻊ ‪Windows API‬‬

‫ﺍﻟﺘﻔﺭﻉ ﻭﺍﻟﺘﻜﺭﺍﺭ‬
‫ﺍﻟﺘﻔﺭﻉ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪If … Then‬‬

‫ﺍﻟﺘﻔﺭﻉ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪Select Case‬‬
‫ﺍﻟﺤﻠﻘﺎﺕ ﺍﻟﺘﻜﺭﺍﺭﻴﺔ‬

‫ﻤﺠﺎﻻﺕ ﺍﻻﺴﻤﺎﺀ‬

‫ﺘﻌﺭﻴﻑ ﻤﺠﺎل ﺍﺴﻤﺎﺀ‬
‫ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﻋﻨﺎﺼﺭ ﻤﺠﺎل ﺍﻻﺴﻤﺎﺀ‬

‫ﺍﺴﺘﻴﺭﺍﺩ ﻤﺠﺎل ﺍﺴﻤﺎﺀ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪Imports‬‬
‫ﺍﺴﺘﻴﺭﺍﺩ ﻤﺠﺎل ﺍﺴﻤﺎﺀ ﺩﻭﻥ ﺍﺴﺘﺨﺩﺍﻡ ‪Imports‬‬
‫ﺍﻟﻔﺼل ﺍﻟﺜﺎﻟﺙ: ﺍﻟﻔﺌﺎﺕ ﻭﺍﻟﻜﺎﺌﻨﺎﺕ‬
‫ﻤﺩﺨﻠﻙ ﺍﻟﺴﺭﻴﻊ ﻟﻠﻔﺌﺎﺕ‬

‫ﺒﻨﺎﺀ ﺍﻋﻀﺎﺀ ﺍﻟﻔﺌﺎﺕ‬
‫ﺍﻟﺤﻘﻭل ‪Fields‬‬

‫ﺍﻟﻁﺭﻕ ‪Methods‬‬
‫ﺍﻟﺨﺼﺎﺌﺹ ‪Properties‬‬
‫ﺍﻻﺤﺩﺍﺙ ‪Event‬‬

‫ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﺎﺌﻨﺎﺕ‬

‫ﻤﺎﻫﻲ ﺤﻘﻴﻘﺔ ﺍﻟﻜﺎﺌﻥ؟‬

‫ﻋﺒﺎﺭﺍﺕ ﺨﺎﺼﺔ ﺒﺎﻟﻜﺎﺌﻨﺎﺕ‬
‫ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ‬

‫ﺤﻴﺎﺓ ﻭﻤﻭﺕ ﺍﻟﻜﺎﺌﻨﺎﺕ‬
‫ﺍﺭﺴﺎل ﺍﻟﻜﺎﺌﻥ ﺒﺎﻟﻤﺭﺠﻊ ﺍﻭ ﺍﻟﻘﻴﻤﺔ‬

‫ﺍﻻﻋﻀﺎﺀ ﺍﻟﻤﺸﺘﺭﻜﺔ‬

‫ﺍﻟﺤﻘﻭل ﺍﻟﻤﺸﺘﺭﻜﺔ ‪Shared Fields‬‬

‫ﺍﻟﻁﺭﻕ ﺍﻟﻤﺸﺘﺭﻜﺔ ‪Shared Methods‬‬
‫ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﻤﺸﺘﺭﻜﺔ ‪Shared Properties‬‬
‫ﺍﻻﺤﺩﺍﺙ ﺍﻟﻤﺸﺘﺭﻜﺔ ‪Shared Events‬‬

‫ﺍﻟﻔﺼل ﺍﻟﺭﺍﺒﻊ: ﺍﻟﻭﺭﺍﺜﺔ‬

‫ﻤﻘﺩﻤﺔ ﺍﻟﻰ ﺍﻟﻭﺭﺍﺜﺔ‬

‫ﻤﺒﺩﺃ ﺍﻟﻭﺭﺍﺜﺔ‬

‫ﺘﻁﺒﻴﻕ ﺍﻟﻭﺭﺍﺜﺔ ﺒـ ‪Visual Basic .NET‬‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻔﺌﺎﺕ ﺍﻟﻭﺍﺭﺜﺔ ﻭﺍﻟﻤﻭﺭﺜﺔ‬
‫ﻭﺭﺍﺜﺔ ﺍﻻﻋﻀﺎﺀ‬

‫ﺍﻟﻤﺸﻴﺩﺍﺕ ‪Constructors‬‬

‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻜﺎﺌﻨﺎﺕ‬
‫ﺍﻋﺎﺩﺓ ﺍﻟﻘﻴﺎﺩﺓ ‪Overriding‬‬

‫ﺍﻋﺎﺩﺓ ﻗﻴﺎﺩﺓ ﺍﻟﻁﺭﻕ ﻭﺍﻟﺨﺼﺎﺌﺹ‬
‫ﺍﺴﺘﺨﺩﺍﻡ ‪MyBase‬‬
‫ﺍﺴﺘﺨﺩﺍﻡ ‪MyClass‬‬

‫ﺍﻟﺘﻅﻠﻴل ‪Shadowing‬‬
‫ﺍﻻﻋﻀﺎﺀ ﺍﻟﻤﺸﺘﺭﻜﺔ ‪Shared Members‬‬
‫ﻜﻠﻤﺎﺕ ﻤﺤﺠﻭﺯﺓ ﺍﻀﺎﻓﻴﺔ‬
‫ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪NotInheritable‬‬
‫ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪MustInherit‬‬

‫ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪MustOverride‬‬

‫ﻤﺤﺩﺩﺍﺕ ﺍﻟﻭﺼﻭل‬

‫ﻗﺎﺒﻠﻴﺔ ﺍﻟﺭﺅﻴﺔ ﻟﻠﻔﺌﺎﺕ‬

‫ﻗﺎﺒﻠﻴﺔ ﺍﻟﺭﺅﻴﺔ ﻻﻋﻀﺎﺀ ﺍﻟﻔﺌﺎﺕ‬

‫ﺘﺄﺜﻴﺭ ﻤﺤﺩﺩﺍﺕ ﺍﻟﻭﺼﻭل ﻋﻠﻰ ﺍﻟﻤﺸﻴﺩﺍﺕ‬
‫ﺍﻟﻔﺼل ﺍﻟﺨﺎﻤﺱ: ﺍﻟﻭﺍﺠﻬﺎﺕ، ﺍﻟﺘﻔﻭﻴﺽ، ﻭﺍﻟﻤﻭﺍﺼﻔﺎﺕ‬
‫ﺍﻟﻭﺍﺠﻬﺎﺕ‬

‫ﺒﻨﺎﺀ ﻭﺍﺠﻬﺔ‬

‫ﺘﻀﻤﻴﻥ ﺍﻟﻭﺍﺠﻬﺔ‬
‫ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﺍﻟﻭﺍﺠﻬﺔ‬
‫ﻭﺭﺍﺜﺔ ﺍﻟﻭﺍﺠﻬﺎﺕ‬

‫ﻭﺍﺠﻬﺎﺕ ﻤﻥ ﺍﻁﺎﺭ ﻋﻤل ‪.NET Framework‬‬
‫ﺍﻟﻭﺍﺠﻬﺔ ‪IComparable‬‬
‫ﺍﻟﻭﺍﺠﻬﺔ ‪ICloneable‬‬
‫ﺍﻟﺘﻔﻭﻴﺽ‬

‫ﺍﻟﻭﺍﺠﻬﺘﺎﻥ ‪ IEnumerable‬ﻭ ‪IEnumerator‬‬
‫ﺍﻻﺠﺭﺍﺀﺍﺕ ﺍﻟﺴﺘﺎﺘﻴﻜﻴﺔ‬
‫ﺍﺠﺭﺍﺀﺍﺕ ﺍﻟﻔﺌﺎﺕ‬
‫ﻤﺤﺎﻜﺎﺓ ﺍﻻﺤﺩﺍﺙ‬

‫ﺩﻤﺞ ﺍﻟﺘﻔﻭﻴﻀﺎﺕ‬

‫ﺍﻟﻤﻭﺍﺼﻔﺎﺕ‬

‫ﺼﻴﻐﺔ ﻜﺘﺎﺒﺔ ﺍﻟﻤﻭﺍﺼﻔﺎﺕ ﻓﻲ ‪Visual Basic .NET‬‬

‫ﻤﻭﺍﺼﻔﺎﺕ ﻤﻥ ﺍﻁﺎﺭ ﻋﻤل ‪.NET Framework‬‬
‫ﺍﻟﻤﻭﺍﺼﻔﺔ ‪Conditional Attribute‬‬

‫ﺍﻟﻤﻭﺍﺼﻔﺔ ‪DebuggerStepThrough Attribute‬‬
‫ﺍﻟﻤﻭﺍﺼﻔﺔ ‪Obsolete Attribute‬‬

‫ﺍﻟﻤﻭﺍﺼﻔﺔ ‪ StructLayout‬ﻭﺍﻟﻤﻭﺍﺼﻔﺔ ‪FieldOffset‬‬

‫ﺒﻨﺎﺀ ﻤﻭﺍﺼﻔﺎﺕ ﺨﺎﺼﺔ‬

‫اﻟﺠﺰء اﻟﺜﺎﻧﻲ: اﻃﺎر ﻋﻤﻞ ‪.NET Framework‬‬
‫ﺍﻟﻔﺼل ﺍﻟﺴﺎﺩﺱ: ﺍﻟﻔﺌﺎﺕ ﺍﻻﺴﺎﺴﻴﺔ‬
‫ﺍﻟﻔﺌﺔ ‪System.Object‬‬
‫ﻁﺭﻕ ﺍﻟﻔﺌﺔ ‪Object‬‬

‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ ﻭﺍﻟﺒﻴﺎﻨﺎﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ ﻤﺭﺓ ﺍﺨﺭﻯ‬
‫ﺍﻟﺼﻨﺩﻗﺔ ﻭﺍﻟﻼﺼﻨﺩﻗﺔ‬

‫ﺍﻟﻔﺌﺎﺕ ﺍﻟﺤﺭﻓﻴﺔ‬

‫ﺍﻟﺨﺼﺎﺌﺹ ﻭﺍﻟﻁﺭﻕ‬
‫ﻤﻘﺎﺭﻨﺔ ﺍﻟﺤﺭﻭﻑ‬

‫ﺍﻟﻔﺌﺔ ‪CultureInfo‬‬
‫ﺍﻟﺒﺤﺙ ﻋﻥ ﺍﻟﺤﺭﻭﻑ‬

‫ﺍﻟﻔﺌﺎﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪Char‬‬
‫ﺍﻟﻔﺌﺎﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪StringBuilder‬‬

‫ﺍﻟﻔﺌﺎﺕ ﺍﻟﻌﺩﺩﻴﺔ‬

‫ﺍﻟﺨﺼﺎﺌﺹ ﻭﺍﻟﻁﺭﻕ‬
‫ﺘﻨﺴﻴﻕ ﺍﻻﻋﺩﺍﺩ‬
‫ﺍﻟﻔﺌﺔ ‪Math‬‬

‫ﺘﻭﻟﻴﺩ ﺍﻻﻋﺩﺍﺩ ﺍﻟﻌﺸﻭﺍﺌﻴﺔ ‪Random Numbers‬‬

‫ﻓﺌﺎﺕ ﺍﺨﺭﻯ‬

‫ﻓﺌﺎﺕ ﺍﻟﻭﻗﺕ ﻭﺍﻟﺘﺎﺭﻴﺦ‬
‫ﺍﻟﻔﺌﺎﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪Enum‬‬
‫ﺍﻟﻔﺌﺎﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪Array‬‬

‫ﻤﺠﺎل ﺍﺴﻤﺎﺀ ‪System.Collections‬‬

‫ﺍﻟﻭﺍﺠﻬﺎﺕ ‪ ICollection‬ﻭ ‪IList‬‬

‫ﺍﻟﻔﺌﺔ ‪Stack‬‬

‫ﺍﻟﻔﺌﺔ ‪Queue‬‬
‫ﺍﻟﻔﺌﺔ ‪3ArrayList‬‬
‫ﺍﻟﻔﺼل ﺍﻟﺴﺎﺒﻊ: ﺍﻜﺘﺸﺎﻑ ﺍﻻﺨﻁﺎﺀ‬
‫ﻓﻜﺭﺓ ﻋﺎﻤﺔ‬

‫ﺍﺨﻁﺎﺀ ﻭﻗﺕ ﺍﻟﺘﺼﻤﻴﻡ‬
‫ﺍﺨﻁﺎﺀ ﻭﻗﺕ ﺍﻟﺘﻨﻔﻴﺫ‬

‫ﺍﻟﺸﻭﺍﺌﺏ‬
‫ﺍﻟﻜﺎﺌﻥ ‪Exception‬‬

‫ﺘﻔﺎﺩﻱ ﺍﻻﺴﺘﺜﻨﺎﺀﺍﺕ ‪Catching Exceptions‬‬
‫ﺭﻤﻲ ﺍﻻﺴﺘﺜﻨﺎﺀﺍﺕ ‪Throwing Exceptions‬‬
‫ﺍﻨﺸﺎﺀ ﻓﺌﺎﺕ ﺍﺴﺘﺜﻨﺎﺀﺍﺕ ﺨﺎﺼﺔ ‪Custom Exceptions‬‬
‫ﺍﻟﻜﺎﺌﻥ ‪Err‬‬

‫ﺘﻔﺎﺩﻱ ﺍﻻﺴﺘﺜﻨﺎﺀﺍﺕ‬
‫ﺭﻤﻲ ﺍﻻﺴﺘﺜﻨﺎﺀﺍﺕ‬

‫ﺍﻻﺨﺘﻴﺎﺭ ﺒﻴﻥ ‪ Exception‬ﻭ ‪Err‬‬
‫ﺍﺩﻭﺍﺕ ﺍﻟﺘﻨﻘﻴﺢ ﻤﻥ ‪Visual Studio .NET‬‬
‫ﺍﺴﺎﻟﻴﺏ ﺍﻟﺘﻨﻔﻴﺫ‬

‫ﻨﻭﺍﻓﺫ ﺍﺨﺭﻯ‬
‫ﺍﻻﻋﺩﺍﺩﺍﺕ ‪Configurations‬‬

‫ﺍﻟﻔﺼل ﺍﻟﺜﺎﻤﻥ: ﺍﻟﻤﻠﻔﺎﺕ ﻭﺍﻟﻤﺠﻠﺩﺍﺕ‬
‫ﺍﻟﻔﺌﺔ ‪Directory‬‬

‫ﻁﺭﻕ ﺘﻌﻭﺩ ﺒﻤﺴﺎﺭﺍﺕ‬

‫ﺍﻟﺒﺤﺙ ﻋﻥ ﺍﻟﻤﻠﻔﺎﺕ ﻭﺍﻟﻤﺠﻠﺩﺍﺕ‬
‫ﺍﻟﻔﺌﺔ ‪File‬‬

‫ﺍﻟﻔﺌﺔ ‪Stream‬‬
‫ﺍﻟﺨﺼﺎﺌﺹ ﻭﺍﻟﻁﺭﻕ ﺍﻟﻤﺸﺘﺭﻜﺔ‬

‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻤﻠﻔﺎﺕ ﺍﻟﻨﺼﻴﺔ‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻤﻠﻔﺎﺕ ﺍﻟﺜﻨﺎﺌﻴﺔ‬

‫ﺘﻜﻭﻴﻥ ‪ Custom Streams‬ﺨﺎﺼﺔ‬
‫ﻓﺌﺎﺕ ﺍﺨﺭﻯ‬
‫ﺍﻟﻔﺌﺔ ‪Path‬‬

‫ﺍﻟﻔﺌﺎﺕ ‪ DirectoryInfo‬ﻭ ‪FileInfo‬‬

‫ﺍﻟﻔﺼل ﺍﻟﺘﺎﺴﻊ: ﺘﺴﻠﺴل ﺍﻟﻜﺎﺌﻨﺎﺕ ‪Object Serialization‬‬
‫ﻤﺩﺨﻠﻙ ﺍﻟﻰ ﺘﺴﻠﺴل ﺍﻟﻜﺎﺌﻨﺎﺕ‬
‫ﻤﺎﻫﻭ ﺍﻟﺘﺴﻠﺴل؟‬
‫ﺍﻟﺘﺴﻠﺴل ﺒﺎﻟﺼﻴﻐﺔ ﺍﻟﺜﻨﺎﺌﻴﺔ ‪Binary Serialization‬‬

‫ﺘﺴﻠﺴل ﺍﻨﻭﺍﻉ ﺒﻴﺎﻨﺎﺕ ﻤﺨﺼﺼﺔ )ﻏﻴﺭ ﻗﻴﺎﺴﻴﺔ(‬
‫ﺨﺭﻴﻁﺔ ﺍﻟﻜﺎﺌﻨﺎﺕ ‪Object Graph‬‬

‫ﻨﺴﺦ ﺍﻟﻜﺎﺌﻨﺎﺕ‬

‫ﺍﻨﺸﺎﺀ ‪ Custom Serialization‬ﺨﺎﺼﺔ‬
‫ﺍﻟﻭﺍﺠﻬﺔ ‪ISerializable‬‬
‫ﻤﺜﺎل ﺘﻁﺒﻴﻘﻲ‬
‫ﺍﻟﺘﺴﻠﺴل ﺒﺼﻴﻐﺔ ‪XML‬‬

‫ﺍﻟﻔﺌﺔ ‪XmlSerializer‬‬
‫ﻤﻭﺍﺼﻔﺎﺕ ﺍﻀﺎﻓﻴﺔ‬
‫ﺍﺤﺩﺍﺙ ﺘﻘﻊ ﻋﻨﺩ ﻋﻜﺱ ﺍﻟﺘﺴﻠﺴل‬

‫ﺍﻟﻔﺼل ﺍﻟﻌﺎﺸﺭ: ﻤﺴﺎﺭﺍﺕ ﺍﻟﺘﻨﻔﻴﺫ ‪Threading‬‬
‫ﻤﻘﺩﻤﺔ ﺍﻟﻰ ﻤﺴﺎﺭﺍﺕ ﺍﻟﺘﻨﻔﻴﺫ‬
‫ﺍﻨﻭﺍﻉ ﻤﺴﺎﺭﺍﺕ ﺍﻟﺘﻨﻔﻴﺫ‬

‫ﻤﺘﻰ ﺘﺴﺘﺨﺩﻡ ﻤﺴﺎﺭﺍﺕ ﺍﻟﺘﻨﻔﻴﺫ ﺍﻟﻤﺘﻌﺩﺩﺓ؟‬

‫ﺍﻨﺸﺎﺀ ﻤﺴﺎﺭ ﺘﻨﻔﻴﺫ‬

‫ﺍﻟﻁﺭﻕ ﻭﺍﻟﺨﺼﺎﺌﺹ‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻤﺴﺎﺭﺍﺕ ﺍﻟﺘﻨﻔﻴﺫ‬

‫ﻤﺸﺎﺭﻜﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬

‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺤﻠﻴﺔ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴﺔ‬
‫ﺍﻟﻤﻭﺍﺼﻔﺔ ‪ThreadStatic Attribute‬‬

‫ﻭﺤﺩﺓ ﺍﻟﺘﺨﺯﻴﻥ ﺍﻟﻤﺤﻠﻴﺔ ‪TLS‬‬

‫ﺘﺒﺎﺩل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﻴﻥ ﻤﺴﺎﺭﺍﺕ ﺍﻟﺘﻨﻔﻴﺫ‬

‫ﺍﻟﺘﺯﺍﻤﻥ ‪Thread Synchronization‬‬

‫ﺍﻟﺘﺭﻜﻴﺏ ‪SyncLock … End SyncLock‬‬

‫ﺍﻟﻤﻭﺍﺼﻔﺔ ‪Synchronization‬‬
‫ﺍﻟﻤﻭﺍﺼﻔﺔ ‪MethodImpl‬‬
‫ﻓﺌﺎﺕ ﺍﺨﺭﻯ‬

‫ﺍﻟﻔﺌﺔ ‪ThreadPool‬‬
‫ﺍﻟﻤﺅﻗﺘﺎﺕ ‪Timers‬‬

‫ﺍﻟﻤﺅﻗﺕ ‪System.Timers.Timer‬‬
‫ﺍﻟﻤﺅﻗﺕ ‪System.Threading.Timer‬‬

‫ﺍﻟﻔﺼل ﺍﻟﺤﺎﺩﻱ ﻋﺸﺭ: ﺍﻟﻤﺠﻤﻌﺎﺕ ‪Assemblies‬‬

‫ﺍﻟﻭﺤﺩﺍﺕ ﺍﻟﻤﺩﺍﺭﺓ ‪Managed Modules‬‬
‫ﺍﻟﻤﺠﻤﻌﺎﺕ ‪Assemblies‬‬

‫ﺍﻟﻤﺠﻤﻌﺎﺕ ﺍﻻﺤﺎﺩﻴﺔ ﻭﺍﻟﻤﺘﻌﺩﺩﺓ ﺍﻟﻤﻠﻔﺎﺕ‬
‫ﺍﺴﺎﻟﻴﺏ ﺘﻨﻔﻴﺫ ﺍﻟﻤﺠﻤﻌﺎﺕ‬

‫ﺍﻟﻤﺠﻤﻌﺎﺕ ﺍﻟﺨﺎﺼﺔ ﻭﺍﻟﻤﺸﺘﺭﻜﺔ‬
‫ﺍﻻﺴﻤﺎﺀ ﺍﻟﻘﻭﻴﺔ ‪Strong Names‬‬
‫ﺍﻟﻤﻭﺍﺼﻔﺔ ‪Assembly‬‬

‫ﻤﻠﻔﺎﺕ ﺍﻟﺘﻬﻴﺌﺔ ‪Configuration Files‬‬
‫ﺍﻨﻭﺍﻉ ﻤﻠﻔﺎﺕ ﺍﻟﺘﻬﻴﺌﺔ‬
‫ﺘﻐﻴﻴﺭ ﺍﻻﻋﺩﺍﺩﺍﺕ‬
‫ﺍﻋﺩﺍﺩﺍﺕ ﻟﻤﻔﺎﺕ ﺍﻟﺘﻬﻴﺌﺔ‬

‫ﺍﺴﺘﺨﺩﺍﻡ ﺍﻻﺩﺍﺓ ‪.NET Framework Configuration‬‬

‫ﺍﺩﻭﺍﺕ ﺍﻟﺘﺭﺠﻤﺔ، ﺍﻟﺭﺒﻁ، ﻭﺍﻟﺘﺴﺠﻴل‬
‫ﺍﻟﻤﺘﺭﺠﻡ ‪VBC.EXE‬‬

‫ﺍﻟﺭﺍﺒﻁ ‪AL.EXE‬‬

‫ﺍﻟﻤﺴﺠل ‪SN.EXE‬‬
‫ﺍﻟﻤﺴﺠل ‪GACUTIL.EXE‬‬

‫ﺍﻟﻔﺼل ﺍﻟﺜﺎﻨﻲ ﻋﺸﺭ: ﻓﺌﺎﺕ ﺍﻻﻨﻌﻜﺎﺱ ‪Reflection Classes‬‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻤﺠﻤﻌﺎﺕ ﻭﺍﻟﻭﺤﺩﺍﺕ ﺍﻟﻤﺩﺍﺭﺓ‬
‫ﺍﻟﻔﺌﺔ ‪Assembly‬‬
‫ﺍﻟﻔﺌﺔ ‪Module‬‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻨﻭﺍﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ﺍﻟﻔﺌﺔ ‪System.Type‬‬

‫ﺨﺼﺎﺌﺹ ﺍﻀﺎﻓﻴﺔ‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻻﻋﻀﺎﺀ‬

‫ﺍﻟﻔﺌﺔ ﺍﻟﻘﺎﻋﺩﻴﺔ ‪MemberInfo‬‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺤﻘﻭل‬

‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻻﺤﺩﺍﺙ‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻁﺭﻕ‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻻﺤﺩﺍﺙ‬

‫ﺍﻟﻭﺴﻴﻁﺎﺕ ‪Parameters‬‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻜﺎﺌﻨﺎﺕ‬

‫ﺍﻟﻔﺌﺔ ‪ReflectionExample‬‬
‫ﺍﺴﻨﺎﺩ/ ﻗﺭﺍﺀﺓ ﻗﻴﻡ ﺍﻟﺤﻘﻭل‬

‫ﺍﺴﻨﺎﺩ/ ﻗﺭﺍﺀﺓ ﻗﻴﻡ ﺍﻟﺨﺼﺎﺌﺹ‬
‫ﺍﺴﺘﺩﻋﺎﺀ ﺍﻟﻁﺭﻕ‬
‫ﻤﻭﺍﻀﻴﻊ ﺍﺨﺭﻯ‬

‫ﺍﻻﻨﺸﺎﺀ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻲ ﻟﻠﻜﺎﺌﻨﺎﺕ‬
‫ﻤﻌﺭﻓﺔ ﺍﻻﺠﺭﺍﺀﺍﺕ ﺍﻟﻤﺴﺘﺩﻋﻴﺔ‬

‫اﻟﺠﺰء اﻟﺜﺎﻟﺚ: ﺗﻄﻮﻳﺮ ﺗﻄﺒﻴﻘﺎت ‪Windows‬‬
‫ﺍﻟﻔﺼل ﺍﻟﺜﺎﻟﺙ ﻋﺸﺭ: ﻨﻤﺎﺫﺝ ‪Windows Forms‬‬
‫ﻤﺩﺨﻠﻙ ﺍﻟﻰ ﻨﻤﺎﺫﺝ ‪Windows Forms‬‬
‫ﻤﺼﻤﻡ ﺍﻟﻨﻤﺎﺫﺝ ‪Form Designer‬‬
‫ﻨﻅﺭﺓ ﺤﻭل ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﻤﻭﻟﺩﺓ‬

‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻜﺜﺭ ﻤﻥ ﻨﻤﻭﺫﺝ‬
‫ﻤﺤل ﺍﻟﻔﺌﺔ ‪ Form‬ﻤﻥ ﺍﻻﻋﺭﺍﺏ‬

‫ﺍﻟﺨﺼﺎﺌﺹ، ﺍﻟﻁﺭﻕ، ﻭﺍﻻﺤﺩﺍﺙ‬
‫ﺨﺼﺎﺌﺹ ﺍﻟﻨﻤﻭﺫﺝ‬
‫ﻁﺭﻕ ﺍﻟﻨﻤﻭﺫﺝ‬

‫ﺍﺤﺩﺍﺙ ﺍﻟﻨﻤﻭﺫﺝ‬
‫ﻨﻤﺎﺫﺝ ‪MDI Forms‬‬

‫ﺍﻟﻨﻭﺍﻓﺫ ﺍﻻﺒﻨﺎﺀ ‪Child Windows‬‬

‫ﺨﺼﺎﺌﺹ ﻭﻁﺭﻕ ﺍﻀﺎﻓﻴﺔ‬

‫ﺍﻟﻘﻭﺍﺌﻡ ‪Menus‬‬

‫ﺍﻟﺨﺼﺎﺌﺹ، ﺍﻟﻁﺭﻕ، ﻭﺍﻻﺤﺩﺍﺙ‬
‫ﺍﻟﻘﻭﺍﺌﻡ ﺍﻟﻤﻨﺒﺜﻘﺔ ‪Popup-Menu‬‬

‫ﻨﻤﺎﺫﺝ ‪ MDI‬ﻤﺭﺓ ﺍﺨﺭﻯ‬
‫ﺍﻻﻨﺸﺎﺀ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻲ ﻟﻠﻘﻭﺍﺌﻡ‬

‫ﻤﻭﺍﻀﻴﻊ ﻤﺘﻘﺩﻤﺔ‬

‫ﺍﻟﺘﻔﺎﻋل ﻤﻊ ﻨﻭﺍﻓﺫ ‪Modeless‬‬
‫ﻭﺭﺍﺜﺔ ﺍﻟﻨﻤﺎﺫﺝ ‪Form Inheritance‬‬
‫ﺍﻟﻨﻤﺎﺫﺝ ﺍﻟﻤﺤﻠﻴﺔ‬

‫ﺍﻟﻔﺼل ﺍﻟﺭﺍﺒﻊ ﻋﺸﺭ: ﺍﻻﺩﻭﺍﺕ ‪Controls‬‬
‫ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﻤﺸﺘﺭﻜﺔ‬

‫ﺍﺴﻡ ﺍﻻﺩﺍﺓ ‪Name‬‬

‫ﺨﺼﺎﺌﺹ ﺍﻟﻤﻅﻬﺭ‬
‫ﺨﺼﺎﺌﺹ ﺍﻟﻤﻭﻗﻊ ﻭﺍﻟﺤﺠﻡ‬
‫ﺨﺼﺎﺌﺹ ﺍﻻﺤﺘﻀﺎﻥ‬
‫ﺨﺼﺎﺌﺹ ﺍﻻﻟﻭﺍﻥ‬

‫ﺨﺼﺎﺌﺹ ﺍﻟﺘﺭﻜﻴﺯ‬
‫ﺨﺼﺎﺌﺹ ﺍﻟﺠﺩﻭﻟﺔ‬
‫ﺨﺼﺎﺌﺹ ﺍﺨﺭﻯ‬
‫ﺍﻟﻁﺭﻕ ﺍﻟﻤﺸﺘﺭﻜﺔ‬

‫ﺍﻻﺤﺩﺍﺙ ﺍﻟﻤﺸﺘﺭﻜﺔ‬
‫ﺍﺤﺩﺍﺙ ﺍﻟﻔﺄﺭﺓ‬
‫ﺍﺤﺩﺍﺙ ﻟﻭﺤﺔ ﺍﻟﻤﻔﺎﺘﻴﺢ‬
‫ﺍﺤﺩﺍﺙ ﺍﻟﺘﺭﻜﻴﺯ‬
‫ﺍﺤﺩﺍﺙ ﺍﺨﺭﻯ‬
‫ﻋﺭﺽ ﺴﺭﻴﻊ ﻟﻼﺩﻭﺍﺕ‬
‫ﺍﻻﺩﺍﺓ ‪Label‬‬
‫ﺍﻻﺩﺍﺓ ‪LinkLabel‬‬
‫ﺍﻻﺩﺍﺓ ‪TextBox‬‬
‫ﺍﻻﺩﺍﺓ ‪Button‬‬
‫ﺍﻻﺩﺍﺓ ‪CheckBox‬‬

‫ﺍﻻﺩﺍﺓ ‪RadioButton‬‬
‫ﺍﻻﺩﺍﺓ ‪ListBox‬‬

‫ﺍﻻﺩﺍﺓ ‪CheckedListBox‬‬
‫ﺍﻻﺩﺍﺓ ‪ComboBox‬‬
‫ﺍﻻﺩﺍﺓ ‪ImageList‬‬

‫ﺍﻻﺩﺍﺓ ‪TreeView‬‬
‫ﺍﻻﺩﺍﺓ ‪ListView‬‬

‫ﺍﻻﺩﺍﺘﻴﻥ ‪ ToolBar‬ﻭ ‪StatusBar‬‬

‫ﺍﻻﺩﺍﺓ ‪Splitter‬‬

‫ﺍﺩﻭﺍﺕ ﺼﻨﺎﺩﻴﻕ ﺍﻟﺤﻭﺍﺭ ﺍﻟﺸﺎﺌﻌﺔ‬
‫ﺍﺩﻭﺍﺕ ﺍﻟﻤﺯﻭﺩﺍﺕ‬
‫ﺍﺩﻭﺍﺕ ﺍﺨﺭﻯ‬

‫ﺘﻘﻨﻴﺔ ﺍﻟﻤﺭﺁﺓ‬

‫ﺍﻟﺨﺎﺼﻴﺔ ‪RightToLeft‬‬

‫ﻗﺼﻭﺭ ﺍﻟﺨﺎﺼﻴﺔ ‪RightToLeft‬‬

‫ﻤﺩﺨﻠﻙ ﺍﻟﻰ ﺘﻘﻨﻴﺔ ﺍﻟﻤﺭﺁﺓ‬

‫ﺘﻁﺒﻴﻕ ﺘﻘﻨﻴﺔ ﺍﻟﻤﺭﺁﺓ ﺒـ ‪Visual Basic .NET‬‬
‫ﻤﺸﺎﻜل ﺍﻀﺎﻓﻴﺔ‬
‫ﺍﺩﻭﺍﺕ ﺼﻨﺎﺩﻴﻕ ﺍﻟﺤﻭﺍﺭ ﺍﻟﺸﺎﺌﻌﺔ‬

‫ﺼﻨﺎﺩﻴﻕ ﺍﻟﺭﺴﺎﺌل‬

‫ﺍﻟﻔﺼل ﺍﻟﺨﺎﻤﺱ ﻋﺸﺭ: ﻤﺒﺎﺩﺉ +‪GDI‬‬
‫ﺍﻟﺭﺴﻡ ﺍﻟﻤﺘﻘﺩﻡ‬

‫ﺍﻟﻜﺎﺌﻥ ‪Graphics‬‬
‫ﺭﺴﻡ ﺍﻟﺨﻁﻭﻁ، ﺍﻟﻤﺴﺘﻁﻴﻼﺕ، ﻭﺍﻟﺩﻭﺍﺌﺭ‬
‫ﺭﺴﻡ ﺍﻟﻤﻨﺤﻨﻴﺎﺕ ﺍﻟﻤﻌﻘﺩﺓ‬
‫ﻜﺎﺌﻥ ﺍﻟﻘﻠﻡ ‪Pen‬‬
‫ﻜﺎﺌﻥ ﻤﺴﺎﺭ ﺍﻟﺭﺴﻡ ‪GraphicsPath‬‬

‫ﺍﻟﺘﻌﺒﺌﺔ‬

‫ﻜﺎﺌﻥ ﺍﻟﻔﺭﺸﺎﺓ ‪Brush‬‬

‫ﺍﻨﻅﻤﺔ ﺍﻟﻘﻴﺎﺱ‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺼﻭﺭ‬

‫ﺘﺤﻤﻴل ﻭﺤﻔﻅ ﺍﻟﺼﻭﺭ‬
‫ﻋﺭﺽ ﺍﻟﺼﻭﺭ‬

‫ﻋﻜﺱ، ﻗﻠﺏ، ﻭﺴﺤﺏ ﺍﻟﺼﻭﺭ‬

‫ﺘﺤﺩﻴﺩ ﺍﻻﻟﻭﺍﻥ‬

‫ﺍﻟﺭﻤﻭﺯ ‪Icons‬‬

‫ﺍﻟﻤﺨﺭﺠﺎﺕ ﺍﻟﻨﺼﻴﺔ‬

‫ﻋﻭﺍﺌل ﺍﻟﺨﻁﻭﻁ‬
‫ﺭﺴﻡ ﺍﻟﻨﺼﻭﺹ‬

‫ﺍﻟﺘﻔﺎﻑ ﺍﻟﻨﺹ‬

‫ﺍﻟﻜﺎﺌﻥ ‪StringFormat‬‬

‫ﻋﻭﺩﺓ ﺍﻟﻰ ﺍﻻﺩﻭﺍﺕ ‪Controls‬‬

‫ﺍﻟﻔﺼل ﺍﻟﺴﺎﺩﺱ ﻋﺸﺭ: ﻤﻭﺍﻀﻴﻊ ﻤﺘﻘﺩﻤﺔ‬
‫ﺘﻁﻭﻴﺭ ﺍﺩﻭﺍﺕ ﺨﺎﺼﺔ‬
‫ﻭﺭﺍﺜﺔ ﺍﺩﺍﺓ‬

‫ﺤﻀﻥ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻻﺩﻭﺍﺕ‬
‫ﺍﻨﺸﺎﺀ ﺍﺩﺍﺓ ﻤﺴﺘﻘﻠﺔ‬

‫ﻟﻤﺴﺎﺕ ﻓﻨﻴﺔ ﺍﻀﺎﻓﻴﺔ‬

‫ﺘﻁﻭﻴﺭ ﺨﺩﻤﺎﺕ ‪Windows‬‬

‫ﻤﻘﺩﻤﺔ ﺍﻟﻰ ﺨﺩﻤﺎﺕ ‪Windows‬‬
‫ﺍﻨﺸﺎﺀ ﻤﺸﺎﺭﻴﻊ ﻤﻥ ﻨﻭﻉ ‪Windows Service‬‬

‫ﺘﺼﺤﻴﺢ ﺍﻟﺸﻴﻔﺭﺓ‬

‫ﺍﻟﻔﺌﺔ ‪System.IO.FileSystemWatcher‬‬
‫ﻜﺘﺎﺒﺔ ﺍﻟﺸﻴﻔﺭﺍﺕ‬

‫ﺘﺴﺠﻴل ﺍﻟﺨﺩﻤﺔ‬
‫ﺍﻻﺩﺍﺓ ‪InstallUtil.EXE‬‬

‫ﻓﺌﺎﺕ ﺍﺨﺭﻯ‬

‫ﺍﻟﻔﺌﺔ ‪Application‬‬
‫ﺍﻟﻔﺌﺔ ‪Cursor‬‬
‫ﺍﻟﻔﺌﺔ ‪SendKeys‬‬

‫ﺍﻟﻔﺌﺘﺎﻥ ‪ Registry‬ﻭ ‪RegistryKey‬‬

‫ﺍﻟﻔﺌﺔ ‪Help‬‬
‫اﻟﺠﺰء اﻟﺮاﺑﻊ: ﺑﺮﻣﺠﺔ ﻗﻮاﻋﺪ اﻟﺒﻴﺎﻧﺎت‬
‫ﺍﻟﻔﺼل ﺍﻟﺴﺎﺒﻊ ﻋﺸﺭ: ﺍﺴﺘﺨﺩﺍﻡ ‪ADO.NET‬‬
‫ﻤﺩﺨﻠﻙ ﺍﻟﻰ ‪ADO.NET‬‬
‫ﺍﻟﻭﻀﻊ ﺍﻟﻤﺘﺼل ﻭﺍﻟﻭﻀﻊ ﺍﻟﻤﻨﻔﺼل‬

‫ﻤﺯﻭﺩﺍﺕ ‪.NET Data Providers‬‬
‫ﻓﺌﺎﺕ ‪ADO.NET‬‬

‫ﻜﺎﺌﻥ ﺍﻻﺘﺼﺎل ‪Connection‬‬
‫ﺍﻨﺸﺎﺀ ﻜﺎﺌﻥ ﺍﺘﺼﺎل‬
‫ﻨﺹ ﺍﻻﺘﺼﺎل‬

‫ﻓﺘﺢ ﻭﺍﻏﻼﻕ ﺍﻻﺘﺼﺎﻻﺕ‬

‫ﻜﺎﺌﻥ ﺍﻻﻭﺍﻤﺭ ‪Command‬‬
‫ﺍﻨﺸﺎﺀ ﻜﺎﺌﻥ ﺍﻭﺍﻤﺭ‬

‫ﺍﻟﺭﺒﻁ ﻤﻊ ﺍﺘﺼﺎل‬

‫ﺘﻨﻔﻴﺫ ﺠﻤل ﺍﻻﺴﺘﻌﻼﻡ ‪SQL‬‬
‫ﻗﺭﺍﺌﺔ ﺍﻟﺴﺠﻼﺕ‬
‫ﻜﺎﺌﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪DataReader‬‬
‫ﺍﻨﺸﺎﺀ ﻜﺎﺌﻥ ﺒﻴﺎﻨﺎﺕ‬
‫ﻗﺭﺍﺌﺔ ﺍﻟﺴﺠﻼﺕ‬

‫ﺨﺎﺹ ﺒﻤﺴﺘﺨﺩﻤﻲ ® ‪Microsoft SQL Server‬‬
‫ﻗﺭﺍﺌﺔ ﻨﺘﺎﺌﺞ ﻤﺘﻌﺩﺩﺓ‬

‫ﺍﻟﻔﺼل ﺍﻟﺜﺎﻤﻥ ﻋﺸﺭ: ‪ ADO.NET‬ﻟﻠﻭﻀﻊ ﺍﻟﻤﻨﻔﺼل‬
‫ﻜﺎﺌﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪DataSet‬‬
‫ﺍﻟﻔﺌﺔ ‪DataTable‬‬
‫ﺍﻟﻔﺌﺔ ‪DataRow‬‬

‫ﺍﻟﻔﺌﺔ ‪DataColumn‬‬

‫ﺍﻟﻔﺌﺔ ‪DataRelation‬‬
‫ﺍﻨﺸﺎﺀ ﻜﺎﺌﻥ ﺒﻴﺎﻨﺎﺕ ‪ DataSet‬ﻤﻥ ﺍﻟﺼﻔﺭ‬
‫ﻜﺎﺌﻥ ﺍﻟﻤﺤﻭل ‪DataAdapter‬‬

‫ﺴﻴﻨﺎﺭﻴﻭ ﺍﻟﻭﻀﻊ ﺍﻟﻤﻨﻔﺼل‬
‫ﺍﻨﺸﺎﺀ ﻜﺎﺌﻥ ﻤﺤﻭل ‪DataAdapter‬‬
‫ﺍﻟﺭﺒﻁ ﻤﻊ ﺍﺘﺼﺎل‬
‫ﻗﺭﺍﺌﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬

‫ﺘﺤﺩﻴﺙ ﺍﻟﺒﻴﺎﻨﺎﺕ‬

‫ﺘﺨﺼﻴﺹ ﺍﻓﻀل ﻟﻠﺨﺼﺎﺌﺹ ‪xxxCommand‬‬
‫ﺍﺘﻘﺎﺀ ﺸﺭ ﺍﻟﺘﻌﺎﺭﻀﺎﺕ‬
‫ﻋﺭﺽ ﺍﻟﺘﻌﺎﺭﻀﺎﺕ‬

‫ﺍﻟﺤﺩﺙ ‪RowUpdated‬‬

‫ﺍﻟﻔﺼل ﺍﻟﺘﺎﺴﻊ ﻋﺸﺭ: ﺭﺒﻁ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﺍﻟﺘﻜﺎﻤل ﻤﻊ ‪XML‬‬
‫ﺭﺒﻁ ﺍﻟﺒﻴﺎﻨﺎﺕ‬

‫ﺍﻨﻭﺍﻉ ﺍﻟﺭﺒﻁ‬
‫ﻤﻴﻜﺎﻨﻴﻜﻴﺔ ﺍﻟﺭﺒﻁ‬

‫ﺍﻟﺭﺒﻁ ﺍﻟﻰ ﻤﺼﻔﻭﻓﺔ‬
‫ﺍﻟﺭﺒﻁ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪ADO.NET‬‬

‫ﺍﻟﺭﺒﻁ ﺍﻟﻤﻌﻘﺩ ‪Complex Binding‬‬
‫ﻓﺌﺎﺕ ﺨﺎﺼﺔ ﺒـ ‪XML‬‬

‫ﺍﻟﻔﺌﺔ ‪XmlTextReader‬‬
‫ﺍﻟﻔﺌﺔ ‪XmlTextWriter‬‬

‫ﺘﻜﺎﻤل ‪ ADO.NET‬ﻭ ‪XML‬‬

‫ﻜﺘﺎﺒﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺼﻴﻐﺔ ‪XML‬‬
‫ﻗﺭﺍﺌﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺼﻴﻐﺔ ‪XML‬‬

‫اﻟﺠﺰء اﻟﺨﺎﻣﺲ: ﺑﺮﻣﺠﺔ وﻳﺐ‬
‫ﺍﻟﻔﺼل ﺍﻟ ﻌﺸﺭﻭﻥ: ﺘﻁﺒﻴﻘﺎﺕ ‪(1) ASP.NET‬‬
‫ﺍﻟﺨﺎﺩﻡ ‪IIS‬‬
‫ﺘﺭﻜﻴﺏ ﺍﻟﺨﺎﺩﻡ ‪IIS‬‬
‫ﺍﻻﺩﻟﺔ ﺍﻟﻭﻫﻤﻴﺔ‬

‫ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﺍﻻﺩﻟﺔ ﺍﻟﻭﻫﻤﻴﺔ‬

‫ﻤﺩﺨﻠﻙ ﺍﻟﻰ ﻨﻤﺎﺫﺝ ‪Web Forms‬‬
‫ﺍﻨﺸﺎﺀ ﺍﻟﻤﺸﺭﻭﻉ‬
‫ﻀﺒﻁ ﺍﻻﻋﺩﺍﺩﺍﺕ ﺍﻟﺭﺌﻴﺴﺔ‬
‫ﻜﺘﺎﺒﺔ ﺍﻟﺸﻴﻔﺭﺍﺕ‬

‫ﺘﺤﻠﻴل ﺍﻟﺸﻴﻔﺭﺓ‬

‫ﺍﺴﺎﻟﻴﺏ ﺘﻨﻔﻴﺫ ﺍﻟﺼﻔﺤﺔ‬
‫ﺍﻟﺨﻼﺼﺔ‬
‫ﺍﻟﻔﺌﺔ ‪Page‬‬

‫ﺨﺼﺎﺌﺹ ﺼﻔﺤﺔ ﺍﻟﻨﻤﻭﺫﺝ‬
‫ﻁﺭﻕ ﺼﻔﺤﺔ ﺍﻟﻨﻤﻭﺫﺝ‬

‫ﺍﺤﺩﺍﺙ ﺼﻔﺤﺔ ﺍﻟﻨﻤﻭﺫﺝ‬
‫ﺍﻻﺩﻭﺍﺕ‬

‫ﻭﺴﻭﻡ ﺍﻀﺎﻓﻴﺔ‬
‫ﺍﺩﻭﺍﺕ ‪Web Forms Controls‬‬
‫ﺍﺩﻭﺍﺕ ‪HTML Forms Controls‬‬
‫ﺍﺩﻭﺍﺕ ﺍﻟﺘﺤﻘﻕ ‪Validation‬‬

‫ﺍﻟﻔﺼل ﺍﻟﺤﺎﺩﻱ ﻭﺍﻟﻌﺸﺭﻭﻥ: ﺘﻁﺒﻴﻘﺎﺕ ‪(2) ASP.NET‬‬
‫ﻜﺎﺌﻨﺎﺕ ﺼﻔﺤﺎﺕ ‪ ASP.NET‬ﺍﻻﺴﺎﺴﻴﺔ‬
‫ﺍﻟﻜﺎﺌﻥ ‪HttpRequest‬‬
‫ﺍﻟﻜﺎﺌﻥ ‪HttpResponse‬‬

‫ﺍﻟﻜﺎﺌﻥ ‪HttpServerUtility‬‬
‫ﺍﻟﻜﺎﺌﻥ ‪HttpApplicationState‬‬
‫ﺍﻟﻜﺎﺌﻥ ‪HttpSessionState‬‬
‫ﺍﻟﻤﻠﻑ ‪Global.asax‬‬

‫ﺍﻻﺠﺭﺍﺀﺍﺕ )(‪ xxxStart‬ﻭ )(‪xxxEnd‬‬

‫ﺍﻻﺠﺭﺍﺀ )(‪Global_Error‬‬
‫ﺍﻻﻤﺎﻥ ‪Security‬‬

‫ﻤﺩﺨﻠﻙ ﺍﻟﻰ ﺍﻟﺼﻼﺤﻴﺎﺕ‬

‫ﺍﻭﻀﺎﻉ ﺍﻟﺘﺼﺩﻴﻕ ﻓﻲ ‪ASP.NET‬‬
‫ﻤﻠﻔﺎﺕ ﺍﻟﺘﻬﻴﺌﺔ‬

‫ﺍﻟﻭﻀﻊ ‪ Forms‬ﻟﻠﺘﺼﺩﻴﻕ‬
‫ﺍﻟﻭﺴﻡ >‪<credentials‬‬

‫ﺼﻔﺤﺔ ﺘﺴﺠﻴل ﺍﻟﺩﺨﻭل ‪Login‬‬
‫ﻤﻭﺍﻀﻴﻊ ﻤﺘﻘﺩﻤﺔ‬

‫ﺍﻟﺘﺨﺯﻴﻥ ‪Caching‬‬

‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﻤﺔ‬

‫ﺤﻤﺎﻴﺔ ﺍﻟﺼﻭﺭ‬

‫ﺍﻻﻨﺸﺎﺀ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻲ ﻟﻠﺼﻭﺭ‬
‫ﻭﺤﺩﺍﺕ ‪HTTP Modules‬‬

‫ﺍﻟﻔﺼل ﺍﻟﺜﺎﻨﻲ ﻭﺍﻟﻌﺸﺭﻭﻥ: ﺨﺩﻤﺎﺕ ﻭﻴﺏ ‪Web Services‬‬
‫ﻤﺩﺨﻠﻙ ﺍﻟﻰ ﺨﺩﻤﺎﺕ ﻭﻴﺏ‬
‫ﻜﻴﻑ ﺘﻌﻤل ﺨﺩﻤﺎﺕ ﻭﻴﺏ؟‬

‫ﺒﻨﺎﺀ ﺨﺩﻤﺔ ﻭﻴﺏ‬

‫ﺍﻨﺸﺎﺀ ﺍﻟﻤﺸﺭﻭﻉ‬
‫ﻜﺘﺎﺒﺔ ﺍﻟﺸﻴﻔﺭﺓ‬

‫ﺍﺨﺘﺒﺎﺭ ﺍﻟﺨﺩﻤﺔ ﻤﻥ ﺍﻟﻤﺘﺼﻔﺢ‬
‫ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺨﺩﻤﺔ‬

‫ﻜﻴﻑ ﺘﻡ ﺍﻟﺭﺒﻁ؟‬

‫ﺘﺤﺩﻴﺙ ﺍﻟﺨﺩﻤﺔ‬

‫ﻤﻌﻠﻭﻤﺎﺕ ﺍﻀﺎﻓﻴﺔ‬

‫اﻟﻤﻼﺣﻖ‬
‫ﺍﻟﻤﻠﺤﻕ ﺃ: ﻟﻐﺔ ﻭﺼﻑ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪XML‬‬
‫ﺍﻟﻤﻠﺤﻕ ﺏ: ﻟﻐﺔ ﺍﻻﺴﺘﻌﻼﻡ ‪SQ L‬‬
‫0‬

‫ﺗﻤﻬﻴﺪ‬

‫ﺗﻘﺪﻳﻢ‬
‫ﻟﻘﺩ ﺍﺴﻌﺩﻨﻲ ﺨﺒﺭ ﺍﻥ ﺘﺭﻜﻲ ﺍﻟﻌﺴﻴﺭﻱ ﻗﺎﻡ ﺒﻜﺘﺎﺒﺔ ﻜﺘﺎﺒﺎ ﺠﺩﻴﺩﺍ ﻋﻥ ﻟﻐﺔ ‪ Visual Basic .NET‬ﻭﺍﻟﺘـﻲ ﺘﻌﺘﺒـﺭ‬

‫ﻟﻐﺔ ﺍﻟﻤﺴﺘﻘﺒل ﻟﻠﻤﻁﻭﺭﻴﻥ ﻭﺍﻟﻤﺒﺭﻤﺠﻴﻥ، ﻭﺍﻥ ﻜﻨﺕ ﻻ ﺘﻌﻠﻡ ﻤﻥ ﻫﻭ ﺘﺭﻜﻲ ﺍﻟﻌﺴﻴﺭﻱ، ﻓﺩﻉ ﻫﺫﺍ ﺍﻟﻜﺘـﺎﺏ ﻴﻌﺭﻓـﻙ‬
‫ﺒﻪ؛ ﻴﻜﻔﻴﻙ ﻤﻘﺎﻻﺘﻪ ﺍﻟﺘﻲ ﺘﻤﻠﺘﺊ ﺒﻬﺎ ﺍﻟﻤﻭﺍﻗﻊ ﺍﻟﻌﺭﺒﻴﺔ ﺤﻭل ﺘﻘﻨﻴﺔ ‪ ،.NET‬ﻭﻻﺘﻨﺴـﻰ ﺍﻨـﻪ ﺍﻟﻤﺅﺴـﺱ ﻟﻠﻤﻭﻗـﻊ‬
‫ﺍﻟﺸﻬﻴﺭ ﺸﺒﻜﺔ ﺍﻟﻤﻁﻭﺭﻭﻥ ﺍﻟﻌﺭﺏ )‪ (dev4arabs.com‬ﻭﻜﺎﺘﺏ ﻟﺠﻤﻴﻊ ﺍﻟﺸﻴﻔﺭﺍﺕ ﺍﻟﻤﺼـﺩﺭﻴﺔ ﺍﻟﺘـﻲ ﺘﻨـﺒﺽ‬

‫ﺍﻟﻤﻭﻗﻊ ﺒﺎﻟﺤﻴﺎﺓ، ﻭﻤﺎ ﻴﺠﻌﻠﻨﻲ ﺃﺸﻌﺭ ﺒﺎﻟﻔﺨﺭ ﻫﻭ ﺃﻥ ﺍﻟﻜﺎﺘﺏ ﻋﺭﺒﻲ ﻭﻴﻭﺠﻪ ﺨﺒﺭﺘﻪ ﻭﻤﻌﺭﻓﺘﻪ ﻟﻠﻌﺭﺏ.‬
‫ﻴﺘﻤﺘﻊ ﺍﻷﺥ ﺘﺭﻜﻲ ﺒﻤﺯﺍﻴﺎ ﺨﺎﺼﺔ ﺴﻭﺍﺀ ﻜﺎﻥ ﻤﺒﺭﻤﺠﺎ ﺍﻭ ﻜﺎﺘﺒﺎ، ﻓﻠﺩﻴـﻪ ﻤـﻥ ﺍﻻﺴـﻠﻭﺏ ﺍﻟـﺫﻱ ﻴﺠﻌﻠـﻙ‬

‫ﺘﺴﺘﻭﻋﺏ ﺍﻻﻤﻭﺭ ﺍﻟﻤﻌﻘﺩﺓ ﻭﻜﺎﻨﻬﺎ ﻤﻌﺎﺩﻟﺔ 1+1=2 ! ﻭﺍﻵﻥ ﺃﺭﻯ ﺃﻨﻪ ﺍﻨﺠﺯ ﻤﺸﺭﻭﻋﺎ )ﻜﻤﺎ ﻴﻠﻘﺏ ﻜﺘﺎﺒـﻪ( ﻴﻌﺘﺒـﺭ‬
‫ﺍﻭل ﻜﺘﺎﺏ ﻤﻥ ﻤﺅﻟﻑ ﻋﺭﺒﻲ ﺤﻭل ﺘﻘﻨﻴﺔ ‪ ،Microsoft .NET‬ﻜﻤـﺎ ﺴـﻁﺭ ﻤﺠﻤﻭﻋـﺔ ﻤـﻥ ﺍﻟﺼـﻔﺤﺎﺕ‬

‫ﻭﺍﻟﻤﻭﺠﻪ ﺨﺼﻴﺼﺎ ﻟﻠﻤﻁﻭﺭ ﺍﻟﻌﺭﺒﻲ.‬

‫ﻜﺨﺒﻴﺭ ﺘﺼﻤﻴﻡ ﻭﺘﻁﻭﻴﺭ ﻤﻭﺍﻗﻊ، ﺃﺭﻯ ﺒﺄﻥ ﺍﻟﻜﺘﺎﺏ ﺴﻴﻔﻴﺩ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺍﻟﻌـﺭﺏ ﺍﻟﺘـﺎﺌﻬﻴﻥ ﻓـﻲ‬

‫ﺘﻘﻨﻴﺔ ‪ ،.NET‬ﻓﻬﺫﻩ ﺍﻟﺘﻘﻨﻴﺔ ﺘﻌﺘﺒﺭ ﺘﻘﻨﻴﺔ ﺍﻟﻤﺴﺘﻘﺒل ﻟﺘﻁﻭﻴﺭ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﻭﻤﻭﺍﻗﻊ ﺍﻹﻨﺘﺭﻨﺕ، ﻭﻫﻲ ﻗﻭﻴﺔ ﺠـﺩﺍ ﻭﻟﻬـﺎ‬
‫ﻤﻥ ﺍﻻﻤﻜﺎﻨﻴﺎﺕ ﻤﺎ ﻴﻔﻭﻕ ﺍﻟﺘﻭﻗﻌﺎﺕ، ﻭﻟﻜـﻥ ﻤﺴـﺎﻟﺔ ﺍﺴـﺘﻴﻌﺎﺒﻬﺎ ﺴـﻴﻜﻭﻥ ﺼـﻌﺒﺎ ﻋﻠـﻰ ﺍﻏﻠـﺏ ﺍﻟﻤﺒـﺭﻤﺠﻴﻥ‬
‫ﺍﻟﻤﺴﺘﺠﺩﻴﻥ ﻭﺍﻟﻤﺨﻀﺭﻤﻴﻥ ﺍﻴﻀﺎ!، ﻫﺫﺍ ﻭﺍﻥ ﻋﻠﻤﺕ ﺍﻨﻬﺎ ﻤﻥ ﺍﺤﺩﺙ ﺍﻟﺘﻘﻨﻴﺎﺕ ﺍﻟﺼﺎﺩﺭﺓ ﻤـﻥ ﻤﻌﺎﻤـل ﺭﻴـﺩﻤﻭﻥ‬

‫ﺒﻭﻻﻴﺔ ﻭﺍﺸﻨﻁﻥ )ﺍﻋﻨﻲ ﻤﻥ ﺸﺭﻜﺔ ‪ ،(Microsoft‬ﻭﻭﺠﻭﺩ ﻤﺼﺩﺭ ﻻﺘﻘﺎﻨﻬﺎ ﻴﺤﺘﺎﺝ ﺍﻟـﻰ ﺠﻬـﺩ ﺠﻬﻴـﺩ، ﻭﻤـﻥ‬
‫ﺍﻟﻨﺎﺩﺭ ﺍﻟﺤﺼﻭل ﻋﻠﻰ ﻤﺭﺠﻊ ﻟﻬﺎ ﺒﺎﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ، ﻓﻜل ﺍﻟﻜﺘﺏ ﺍﻟﻌﺭﺒﻴﺔ ﻭﺍﻟﺨﺎﺼﺔ ﺒﺘﻘﻨﻴﺔ ‪ .NET‬ﻤﺘﺭﺠﻤﺔ، ﻓﻤـﺎ‬

‫ﺒﺎﻟﻜﻡ ﺇﺫﺍ ﻜﺎﻥ ﺍﻟﻜﺎﺘﺏ ﻋﺭﺒﻲ ﻴﻌﺭﻑ ﻜﻴﻑ ﻨﻔﻜﺭ ﻭﻤﺎﻫﻲ ﻤﺘﻁﻠﺒﺎﺘﻨﺎ ﻭﺇﻟﻰ ﻤﺎﺫﺍ ﻨﺘﻁﻠﻊ ﺃﻭ ﻨﺘﻭﻗﻊ ﻤﻥ ﻜﺘـﺎﺏ ﺒﻬـﺫﺍ‬
‫ﺍﻟﺤﺠﻡ ﻭﺍﻟﺘﺨﺼﺹ.‬
‫ﻴﺘﻤﻴﺯ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﺒﺎﻟﻨﻤﻁ ﺍﻻﺴﺘﻴﻌﺎﺒﻲ ﺍﻟﺫﻱ ﻴﺘﻌﻤﺩﻩ ﺍﻟﻤﺅﻟﻑ، ﻓﻬﻭ ﻴﺭﻜﺯ ﻋﻠﻰ ﺍﻟﺴـﻬﻭﻟﺔ ﻭﺍﻟﻤﻨﻁـﻕ ﻓـﻲ‬

‫ﺍﻟﺘﺴﻠﺴل ﻹﻴﺼﺎل ﺍﻟﻤﻌﻠﻭﻤﺔ ﻟﻠﻘﺎﺭﺉ ﻭﻫﺫﺍ ﻤﺎ ﻴﻌﺭﻑ ﻋﻥ ﺍﻟﻜﺎﺘﺏ، ﻓﺄﺴﻠﻭﺒﻪ ﺴﻠﺱ ﻭﺩﺍﺌﻤـﺎ ﻤـﺎ ﻴﺤـﺎﻭل ﺍﻟﻨـﺯﻭل‬
‫ﹰ‬
‫ﻟﻤﺴﺘﻭﻯ ﺍﻟﻘﺎﺭﺉ ﺜﻡ ﻴﺭﺘﻘﻲ ﺒﻪ ﻜﻠﻤﺎ ﺍﺴﺘﻤﺭ ﻓﻲ ﺍﻟﻘﺭﺍﺀﺓ، ﻜﻤﺎ ﺍﻨﻪ ﻴﻀﻔﻲ ﻋﻠﻰ ﺍﻟﻜﺘﺎﺏ ﺍﺴﻠﻭﺏ ﺍﻟﻤﺤـﺎﻭﺭﺓ ﻤﻤـﺎ‬

‫ﻴﻭﺤﻲ ﺍﻥ ﺍﻟﻤﺅﻟﻑ ﺍﻤﺎﻤﻙ ﻭﻴﻨﺎﻗﺸﻙ ﻓﻲ ﺍﻟﻤﻭﺍﻀﻴﻊ ﻭﻜﺄﻨﻙ ﻓﻲ ﻗﺎﻋﺔ ﻤﺤـﺎﻅﺭﺓ، ﺍﻀـﻑ ﺍﻟـﻰ ﺫﻟـﻙ ﺍﻻﻤﺜﻠـﺔ‬
‫ﺍﻟﻔﻭﺭﻴﺔ ﺍﻟﺘﻲ ﻴﻌﺭﻀﻬﺎ ﻋﻨﺩ ﺍﻟﺤﺩﻴﺙ ﺒﻌﺩ ﺸﺭﺡ ﻜل ﻨﻘﻁﺔ، ﻓﻬﻲ ﻟﻴﺴﺕ ﻜﺒﻴﺭﺓ ﻟﻴﺼﻌﺏ ﺘﺘﺒﻌﻬﺎ.‬

‫ﺍﻤﺎ ﻋﻥ ﺍﻟﻤﺴﺎﻟﺔ ﺍﻟﺘﺠﺎﺭﻴﺔ، ﻓﻭﺍﻀﺢ ﻤﻥ ﺍﻷﺴﻠﻭﺏ ﻓﻲ ﺍﻟﻜﺘﺎﺒﺔ ﻭﻭﻓﺭﺓ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺒﺄﻥ ﺍﻟﻜﺎﺘـﺏ ﺤـﺭﻴﺹ‬

‫ﻋﻠﻰ ﺇﻴﺼﺎل ﺃﻜﺒﺭ ﻗﺩﺭ ﻤﻥ ﺍﻟﻤﻌﺭﻓﺔ ﻟﻴﺠﻌل ﺍﻟﻘﺎﺭﺉ ﻴﺘﻌﻠﻡ ﺃﻜﺜﺭ ﻗﺩﺭ ﻤﻤﻜﻥ ﻭﺒﺎﻟﺘﺎﻟﻲ ﻴﺴﺘﻁﻴﻊ ﺘﻁﺒﻴﻕ ﻤـﺎ ﺘﻌﻠﻤـﻪ‬
‫ﻭﺍﻹﺴﺘﻔﺎﺩﺓ ﻤﻥ ﻗﺭﺍﺀﺓ ﺍﻟﻜﺘﺎﺏ، ﻓﻼ ﻴﻘﻭﻡ ﺒﻨﺴﺦ ﺠﺩﺍﻭل ﻭﺜﺎﺌﻕ ‪ .NET Documentation‬ﻟﻠﺘﻜﺜﻴﺭ ﻤـﻥ ﻋـﺩﺩ‬
‫ب‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺍﻟﺼﻔﺤﺎﺕ ﻭﺯﻴﺎﺩﺓ ﺍﻟﺩﺨل ﻜﻤﺎ ﺘﻔﻌل ﺍﻏﻠﺏ ﺍﻟﻜﺘﺏ ﺍﻟﻤﻨﺘﺸﺭﺓ ﻓـﻲ ﺍﻻﺴـﻭﺍﻕ، ﻓﻤﻌﻅـﻡ ﻫـﺫﻩ ﺍﻟﻜﺘـﺏ ﺘﺘﺠـﺎﻭﺯ‬
‫ﺼﻔﺤﺎﺘﻬﺎ ﺍﻻﻟﻑ ﺼﻔﺤﺔ، ﻭﺒﻌﺩ ﺸﺭﺡ ﻜل ﻨﻘﻁﺔ ﻴﻘﻭﻡ ﺍﻟﻤﺅﻟﻑ ﺒﻌﺭﺽ ﺠﺩﻭل ﻤﻨﺴﻭﺥ ﻤـﻥ ﻭﺜـﺎﻕ‬

‫‪.NET‬‬

‫‪ Documentation‬ﻭﺍﻀﺎﻓﺘﻪ. ﻭﻟﻜﻥ ﻤﻊ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻓﻠﻥ ﻴﺤﺩﺙ ﻤﻌﻙ ﺫﻟﻙ، ﺤﻴﺙ ﺍﻨـﻙ ﺴـﺘﻼﺤﻅ ﺠﻤﻠـﺔ‬

‫ﺍﻟﻤﺅﻟﻑ ﺍﻟﻤﺘﻜﺭﺭﺓ "ﺭﺍﺠﻊ ﻤﻜﺘﺒﺔ ‪ MSDN‬ﻟﻤﺯﻴﺩ ﻤﻥ ﺍﻟﺘﻔﺎﺼﻴل" ﻭﻫﺫﺍ ﺨﻴﺭ ﺩﻟﻴل ﻋﻠـﻰ ﺍﻥ ﺍﻟﻜﺎﺘـﺏ ﻻ ﻴﺭﻴـﺩ‬
‫ﺯﻴﺎﺩﺓ ﺍﻟﺼﻔﺤﺎﺕ ﺍﻟﻤﻨﺴﻭﺨﺔ ﻤﻥ ﻭﺜﺎﺌﻕ ‪ .NET Documentation‬ﻭﺘﻜﺭﺍﺭﻫﺎ ﻓﻲ ﻜﺘﺎﺒﻪ.‬

‫ﻭﺨﺘﺎﻤﺎ ﺃﺘﻤﻨﻰ ﻤﻥ ﺍﷲ ﺃﻥ ﻴﻭﻓﻕ ﺍﻟﻤﺅﻟﻑ ﻓﻲ ﻨﺸﺭ ﺍﻟﻤﻌﺭﻓﺔ ﻟﻠﻌﺭﺏ، ﻭﺃﻥ ﻴﺒﺩﺃ ﺍﻟﺸـﺒﺎﺏ ﺒﺎﻟﻤﻀـﻲ ﻗـﺩﻤﺎ‬
‫ﹰ‬
‫ﹰ‬
‫ﻓﻲ ﻤﺠﺎل ﺍﻟﻨﺸﺭ ﻭﺍﻟﺘﻌﻠﻴﻡ ﻷﻨﻪ ﺴﻼﺡ ﺍﻟﻌﺼﺭ، ﻭﺍﻨﺎ ﻭﺍﺜﻕ ﻜﺎﻤل ﺍﻟﺜﻘﺔ ﺒﺄﻨﻙ ﻟﻥ ﺘﺸﻌﺭ ﺒﺎﻟﻨﺩﻡ ﺒﻌـﺩ ﺍﻗﺘﻨﺎﺌـﻙ ﻟﻬـﺫﺍ‬

‫ﺍﻟﻜﺘﺎﺏ، ﻭﻟﻥ ﺘﻀﻌﻪ ﻤﻊ ﺍﻟﻜﺘﺏ ﺍﻻﺨﺭﻯ ﻓﻲ ﺭﻓﻭﻑ ﻤﻜﺘﺒﺘﻙ، ﺒل ﺴﻴﻅل ﻨﺎﺼﺒﺎ ﻋﻠﻰ ﺴﻁﺢ ﻤﻜﺘﺒﻙ.‬

‫ﺘﻨﺒﻴﻪ ﺍﺨﻴﺭ ﻨﺎﺘﺞ ﻤﻥ ﺘﺠﺭﺒﺔ ﺸﺨﺼﻴﺔ: ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﻤﻔﺎﺠﺌﺎﺕ ﻭﺍﻻﻓﻜﺎﺭ ﺴﺘﺠﺩﻫﺎ ﻓـﻲ ﻫـﺫﺍ ﺍﻟﻜﺘـﺎﺏ،‬

‫ﻟﺫﻟﻙ ﻻ ﺘﻘﺭﺃ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻗﺒل ﻤﻭﻋﺩ ﺍﻟﻨﻭﻡ ﺒﺩﻗﺎﺌﻕ ﺤﻴﺙ ﺍﻨـﻙ ﻟـﻥ ﺘﺴـﺘﻁﻴﻊ ﺍﻟﻨـﻭﻡ ﺩﻭﻥ ﺘﺠﺭﺒـﺔ ﺍﻟﺸـﻴﻔﺭﺍﺕ‬
‫ﺍﻟﻤﺼﺩﺭﻴﺔ ﺒﻨﻔﺴﻙ!‬

‫ﺇﻴﺎﺩ ﻴﺤﻴﻰ ﻤﻜﻲ ﺯﻜﺭﻱ،‬

‫ﻋﻀﻭ ﻓﻲ ﺍﻹﺘﺤﺎﺩ ﺍﻟﻌﺎﻟﻤﻲ ﻟﻤﺼﻤﻤﻲ ﻭﻤﺩﺭﺍﺀ ﺍﻟﻤﻭﻗﻊ ‪.(iawmd.com) IAWMD‬‬
‫ﺍﻟﻤﺅﺴﺱ ﺍﻟﻤﺸﺎﺭﻙ ﻟﺸﺭﻜﺔ ﺍﻹﻨﺘﺭﻨﺕ ﻟﻠﺠﻤﻴﻊ ﺒﺎﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ‪.(ifawal.com) IFAWAL‬‬
‫ج‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫اﻟﻤﻘﺪﻣﺔ‬
‫ﻋﻨﺩﻤﺎ ﺸﺭﻋﺕ ﻓﻲ ﻜﺘﺎﺒﺔ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ، ﺨﺎﻨﺘﻨﻲ ﺍﻟﻌﺒﺭﺓ ﻭﻟـﻡ ﺘـﺎﺘﻲ ﺍﻟﺘﻭﻗﻌـﺎﺕ ﻜﻤـﺎ ﺭﺴـﻤﺕ ﻓـﻲ ﺍﻟﺨـﺎﻁﺭ،‬
‫ﻓﺎﻟﻤﻭﻀﻭﻉ ﺍﻜﺒﺭ ﻤﻥ ﻜﻭﻨﻪ ﺸﺭﺡ ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﻭﺍﺠﺭﺍﺀ ﺘﻁﺒﻴﻘﺎﺕ ﺒﻬﺎ، ﺤﻴﺙ ﺍﻥ ﻜﺘﺎﺒﺔ ﻜﺘﺎﺏ ﻋﻥ ﻟﻐـﺔ ﺍﻟﺒﺭﻤﺠـﺔ‬
‫‪ Visual Basic .NET‬ﻟﻴﺱ ﺴﻭﻯ ﻟﻬﺠﺔ ﺒﻠﺴﺎﻥ ﺍﺨﺭ ﺘﺨﺎﻁﺏ ﺒﻬﺎ ﺘﻘﻨﻴﺔ ‪.Microsoft .NET‬‬

‫ﺴﻭﺍﺀ ﻜﻨﺕ ﻤﺒﺭﻤﺞ ‪ Visual Basic .NET‬ﺍﻭ ﻤﺒﺭﻤﺞ ‪ Visual C# .NET‬ﺍﻭ ﺍﻱ ﻟﻐـﺔ ﺒﺭﻤﺠـﺔ‬

‫ﺍﺨﺭﻯ ﻤﻭﺠﻬﻪ ﺍﻟﻰ ﺍﻁﺎﺭ ﻋﻤل ‪ .NET Framework‬ﻓﻠﻥ ﺘﻘﺩﻡ ﻭﻟﻥ ﺘﺎﺨﺭ ﺫﻟﻙ ﺍﻟﺸﺊ ﺍﻟﻜﺒﻴـﺭ، ﺍﺫ ﺍﻥ ﺍﻟﻠﻘـﺏ‬
‫ﺍﻟﺫﻱ ﻋﻠﻴﻙ ﺍﻟﺒﺤﺙ ﻋﻨﻪ ﺩﺍﺌﻤﺎ ﻫﻭ ﻤﺒﺭﻤﺞ ‪ .NET‬ﺍﻭ –ﻟﻤﺯﻴـﺩ ﻤـﻥ ﺍﻟﺘﻔﺼـﻴل - ﻤﺒـﺭﻤﺞ ‪ .NET‬ﺒﻠﻬﺠـﺔ‬
‫‪ .Visual Basic .NET‬ﻭﺍﻥ ﻟﻡ ﻴﺘﻀﺢ ﻟﻙ ﺍﻟﻤﻌﻨﻰ ﻤﻥ ﺍﻟﻠﻘﺏ ﻤﺒﺭﻤﺞ ‪ ،.NET‬ﻓﻌﻠﻴـﻙ ﻤﻌﺭﻓـﺔ ﺍﻥ ﻟﻐـﺔ‬

‫ﺍﻟﺒﺭﻤﺠﺔ ‪ Visual Basic .NET‬ﻟﻴﺴﺕ ﺴﻭﻯ ﻤﻔﺘﺎﺡ ﺒﺴﻴﻁ ﺘﺴﺘﺨﺩﻤﻪ ﻟﻠﺒـﺎﺏ ﺍﻟﻤﻌﻘـﺩ ﻭﺍﻟﻤﺴـﻤﻰ ‪.NET‬‬
‫‪ ،Framework‬ﻓﺎﻻﺤﺘﺭﺍﻑ ﻓﻲ ﺒﺭﻤﺠﺔ ‪ Visual Basic .NET‬ﻟﻥ ﻴﺘﻁﻠﺏ ﻤﻨﻙ ﺫﻟﻙ ﺍﻟﺠﻬﺩ ﻟﻠﻭﺼﻭل ﺍﻟﻴـﻪ‬
‫ﻓﻲ ﺍﻴﺎﻤﺎ ﻤﻌﺩﻭﺩﺍﺕ ) ﻗﺭﺍﺀﺓ ﺍﻟﻔﺼﻭل ﺍﻟﺨﻤﺱ ﺍﻻﻭﻟﻰ ﻤﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻜﺎﻓﻴﺔ ﺍﻟﻰ ﺤﺩ ﻜﺒﻴـﺭ(، ﺍﻤـﺎ ﺍﻻﺤﺘـﺭﺍﻑ‬
‫ﻓﻲ ﺘﻘﻨﻴﺔ ‪ .NET‬ﻓﻴﺤﺘﺎﺝ ﺍﻟﻰ ﺘﻔﺭﻍ ﺫﻫﻨﻲ ﻤﻥ ﻜل ﺸﺊ ﻓﻲ ﺤﻴﺎﺘﻙ ﺘﻘﺭﻴﺒﺎ.‬

‫ﺍﻁﺎﺭ ﻋﻤل ‪ .NET Framework‬ﻤﻌﻘﺩ ﺠﺩﺍ، ﻭﻫﻭ ﺒﺤﺭ ﻟﻴﺱ ﻟﻪ ﺒﺩﺍﻴﺔ ﻭﻻ ﻨﻬﺎﻴﺔ، ﻭﻗـﺩ ﻻ ﺍﺒـﺎﻟﻎ ﺍﻥ‬

‫ﻗﻠﺕ ﺍﻥ ﻜل ﻤﻴﻨﺎﺀ ﻤﻥ ﻤﻭﺍﻨﻲ ﻫﺫﺍ ﺍﻟﺒﺤﺭ ﺘﺤﺘـﺎﺝ ﺍﻟـﻰ ﻜﺘـﺎﺏ ﻤﺨﺼـﺹ. ﻓـﺂﻻﻑ ﺍﻟﺼـﻔﺤﺎﺕ ﻭﺍﻟﺨﺎﺼـﺔ‬

‫ﺒﻤﺴﺘﻨﺩﺍﺕ ﺘﻘﻨﻴﺔ ‪ Microsoft .NET‬ﺍﻟﺭﺴﻤﻴﺔ ﺨﻴﺭ ﺩﻟﻴل. ﻭﻟﺘﻘﺩﻴﻡ ﻜﺘﺎﺏ ﻋﻥ ﻫﺫﻩ ﺍﻟﺘﻘﻨﻴﺔ، ﻜﺎﻥ ﻋﻠـﻲ ﺍﺨﺘﻴـﺎﺭ‬
‫ﺍﺤﺩ ﺍﻟﺤﻠﻭل ﺍﻟﺜﻼﺙ:‬

‫ﺍﻻﻭل ﻫﻭ ﻜﺘﺎﺒﺔ ﻜﺘﺏ ﻤﺘﻌﺩﺩﺓ ﻴﺨﺘﺹ ﻜل ﻭﺍﺤﺩ ﻓﻴﻬﺎ ﺒﻤﺠﺎل ﻤﻌـﻴﻥ، ﻜﺘـﺎﺏ ﻋـﻥ ﺘﻁـﻭﻴﺭ ﺘﻁﺒﻴﻘـﺎﺕ‬

‫‪ Windows‬ﻭﺍﺨﺭ ﻋﻥ ﺒﺭﻤﺠﺔ ﻭﻴﺏ، ﻭﺜﺎﻟﺙ ﻋﻥ ﺍﻻﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﺘﻘﺩﻡ ﻟﺘﻘﻨﻴـﺔ ‪ ADO.NET‬ﻟﺒﺭﻤﺠـﺔ ﻗﻭﺍﻋـﺩ‬

‫ﺍﻟﺒﻴﺎﻨﺎﺕ، ﻭﻟﻜﻥ ﻴﻌﻴﺒﻪ ﺍﻟﻭﻗﺕ ﺍﻟﻁﻭﻴل ﺍﻟﺫﻱ ﺴﻴﺴﺘﻐﺭﻗﻪ ﺒﺎﻻﻀﺎﻓﺔ ﺍﻟﻰ ﺍﻥ ﺠﻤﻴﻌﻬـﺎ ﺘﺘﻁﻠـﺏ ﺸـﺭﺡ ﺍﺴﺎﺴـﻴﺎﺕ‬

‫ﺍﻟﻠﻐﺔ، ﻤﻤﺎ ﻴﻌﻨﻲ ﺘﻜﺭﺍﺭ ﻤﻌﻅﻡ ﺍﻟﺼﻔﺤﺎﺕ. ﺍﻟﺤل ﺍﻟﺜﺎﻨﻲ، ﻫﻭ ﻤﺸﺎﺭﻜﺔ ﻜﺘﺎﺏ ﺍﺨﺭﻴﻥ ﻭﻤﺤﺎﻭﻟﺔ ﺘﻭﺴـﻌﺔ ﻭﺯﻴـﺎﺩﺓ‬
‫ﺍﻟﻤﺎﺩﺓ ﺍﻟﻌﻠﻤﻴﺔ ﻓﻲ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ، ﻭﻟﻜﻥ ﻴﻌﻴﺒﻪ ﺍﺨﺘﻼﻑ ﺍﻻﺴﺎﻟﻴﺏ ﺍﻟﺘﻲ ﻴﺘﺒﻌﻬـﺎ ﻜـل ﻤﺅﻟـﻑ ﻤﻤـﺎ ﻗـﺩ ﻴﺴـﺒﺏ‬
‫ﺍﻟﺘﺸﻭﻴﺵ ﻋﻠﻰ ﺍﻟﻘﺎﺭﺉ. ﺍﻤﺎ ﺍﻟﺤل ﺍﻟﺜﺎﻟﺙ ﻓﻬﻭ ﺍﻗﺘﻁﺎﻑ ﻤﻥ ﻜل ﺒﺴﺘﺎﻥ ﺯﻫﺭﺓ ﻭﻭﻀﻌﻬﺎ ﻜﻤﻘﺩﻤـﺔ ﻭﻤـﺩﺨل ﻟـﻙ‬

‫ﻴﻤﻜﻨﻙ ﻤﻥ ﺍﻻﻨﻁﻼﻕ ﻤﻨﻪ، ﻭﻫﺫﺍ ﻤﺎ ﻓﻌﻠﺘﻪ ﻓﻲ ﻜﺘﺎﺏ ﺒﺭﻤﺠـﺔ ﺍﻁـﺎﺭ ﻋﻤـل ‪ .NET‬ﺒﺎﺴـﺘﺨﺩﺍﻡ ‪Visual‬‬
‫‪.Basic .NET‬‬

‫ﻟﻤﻦ هﺬا اﻟﻜﺘﺎب؟‬

‫ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻟﻠﻤﺒﺘﺩﺌﻴﻥ ﺍﻡ ﻟﻠﻤﺘﻭﺴﻁﻴﻥ ﺍﻭ ﻟﻠﻤﺤﺘﺭﻓﻴﻥ؟ ﺴﺅﺍل ﻴﺭﺍﻭﺩ ﺍﻏﻠﺏ ﺍﻟﻤﺒـﺭﻤﺠﻴﻥ، ﻭﻴﻬﺘﻤـﻭﻥ ﻓـﻲ ﺍﺠﺎﺒﺘـﻪ‬

‫ﺍﻜﺜﺭ ﻤﻥ ﺍﻫﺘﻤﺎﻤﻬﻡ ﺒﻤﺅﻟﻑ ﺍﻟﻜﺘﺎﺏ. ﻟﻜل ﺍﻨﺴﺎﻥ ﻤﻘﻴﺎﺱ ﺨﺎﺹ ﻟﺘﺼﻨﻴﻑ ﺍﻟﻤﺴـﺘﻭﻴﺎﺕ، ﻭﻗـﺩ ﻴﻜـﻭﻥ ﻤﻘﻴﺎﺴـﻲ‬
‫ﺍﻟﺸﺨﺼﻲ ﻤﺭﻓﻭﺽ ﻤﻥ ﻗﺒل ﺍﻟﻜﺜﻴﺭﻴﻥ، ﻟﺫﻟﻙ ﻟﻥ ﺍﻋﻁﻴﻙ ﺍﺠﺎﺒﺔ ﻤﺒﺎﺸﺭﺓ ﻟﻬﺫﺍ ﺍﻟﺴﺅﺍل، ﻭﺴﺄﻜﺘﻔﻲ ﺒـﺫﻜﺭ ﺼـﻔﺎﺕ‬
‫ﺍﻻﺸﺨﺎﺹ ﺍﻟﺫﻴﻥ ﺍﻋﺘﻘﺩ ﺍﻥ ﺍﻟﻜﺘﺎﺏ ﺴﻴﻜﻭﻥ ﻤﻨﺎﺴﺏ ﻟﻪ ﻤﻥ ﻨﻅﺭﺘﻲ ﺍﻟﺸﺨﺼﻴﺔ.‬
‫د‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺍﺴﺘﻁﻴﻊ ﺘﺼﻨﻴﻑ ﻜﺘﺏ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻰ ﺍﺭﺒﻊ ﺍﻨـﻭﺍﻉ، ﺍﻟﻨـﻭﻉ ﺍﻻﻭل ﻭﻫـﻭ ﺍﻟﺘﻌﻠﻴﻤـﻲ ‪Tutorial‬‬
‫ﺤﻴﺙ ﻴﻭﺠﻪ ﺍﻟﻰ ﺍﻻﺸﺨﺎﺹ ﺍﻟﺫﻴﻥ ﻟﻴﺱ ﻟﺩﻴﻬﻡ ﺍﻟﻭﻗﺕ ﺍﻟﻜﺎﻓﻲ ﻟﻠﻘﺭﺍﺀﺓ، ﻭﻻ ﻴﻭﺩﻭﻥ ﺍﺴﺘﻴﻌﺎﺏ ﺍﻟﻤﺒـﺎﺩﺉ ﺒﻘـﺩﺭ ﻤـﺎ‬

‫ﻴﻬﻤﻬﻡ ﺍﻨﺠﺎﺯﻫﺎ. ﻓﺴﺘﺠﺩ ﻓﻲ ﻤﺜل ﻫﺫﻩ ﺍﻟﻨﻭﻋﻴﺔ ﻤﻥ ﺍﻟﻜﺘﺏ ﻋﺸﺭﺍﺕ ﺍﻟﺴﻁﻭﺭ ﺍﻟﻤﺘﻤﺜل ﻓﻲ ﺨﻁـﻭﺍﺕ ‪Step by‬‬
‫‪ Step‬ﻤﺭﻗﻤﺔ ﺘﻘﻭﻡ ﺒﺎﻨﺠﺎﺯ ﻤﻬﻤﺔ ﻤﻌﻴﻨﺔ ﺩﻭﻥ ﺫﻟﻙ ﺍﻟﺸﺭﺡ.‬

‫ﺍﻟﻨﻭﻉ ﺍﻟﺜﺎﻨﻲ ﻫﻭ ﺍﻟﻤﺭﺍﺠﻊ ‪ ،Reference‬ﻭﻫﻲ ﻜﺘﺏ ﻻ ﺘﻘﺭﺃ ﻤﻥ ﺍﻟﻐﻼﻑ ﺍﻟﻰ ﺍﻟﻐﻼﻑ ﻭﺍﻨﻤـﺎ ﻴﺭﺠـﻊ‬

‫ﻟﻬﺎ ﻤﻥ ﻭﻗﺕ ﻻﺨﺭ. ﻭﻜﻤﺎ ﺘﻌﻠﻡ ﺍﻥ ﺍﻟﻤﺭﺍﺠﻊ ﺘﻜﺘﺏ ﻤﻥ ﻗﺒل ﺍﻻﻑ ﺍﻻﺸﺨﺎﺹ، ﻭﻗـﺩ ﺍﺤﺘـﺎﺝ ﻟﻠﻜﺘﺎﺒـﺔ ﺒﺎﺼـﺎﺒﻊ‬
‫ﻗﺩﻤﻲ ﺤﺘﻰ ﺍﻨﺠﺯ ﻤﺭﺠﻊ ﻗﺒل ﺍﻥ ﺘﺸﻴﺏ ﺸﻌﺭﺍﺕ ﺭﺃﺴﻲ.‬

‫ﺍﻟﻨﻭﻉ ﺍﻟﺜﺎﻟﺙ ﻤﻥ ﺍﻨﻭﺍﻉ ﺍﻟﻜﺘﺏ ﻫﻭ ﻭﺭﺸﺔ ﺍﻟﻌﻠﻡ ‪ ،Workshop‬ﻭﻫـﻭ ﻋﻨـﺩﻤﺎ ﻴﻤﻴـل ﺍﻟﻜﺘـﺎﺏ ﺍﻟـﻰ‬

‫ﺍﻟﺠﺎﻨﺏ ﺍﻟﺘﻁﺒﻴﻘﻲ ﺍﻜﺜﺭ ﻤﻥ ﺍﻟﺸﺭﺡ، ﻭﻟﻜﻥ ﻴﻔﺘﺭﺽ ﺍﻟﻤﺅﻟﻑ ﺍﻨﻙ ﺘﻌﻠﻡ ﻜل ﺸﺊ ﻋـﻥ ﻟﻐـﺔ ﺍﻟﺒﺭﻤﺠـﺔ، ﺤﻴـﺙ‬

‫ﻴﻌﺭﺽ ﻟﻙ ﺍﻻﺴﺎﻟﻴﺏ ﺍﻟﺒﺭﻤﺠﻴﺔ ﺍﻟﻤﺘﻌﺩﺩﺓ ﻻﻨﺠﺎﺯ ﺍﻟﻤﻬﺎﻡ ﻭﺘﻁﺒﻴﻘﻬﺎ ﻤﺒﺎﺸﺭﺓ.‬

‫ﺍﻤﺎ ﺍﻟﻜﺘﺎﺏ ﺍﻟﺫﻱ ﺍﻤﺎﻡ ﻋﻴﻨﻴﻙ ﻓﻬﻭ ﻤﻥ ﺍﻟﻨﻭﻉ ﺍﻟﺭﺍﺒﻊ ﻭ ﻫـﻭ ﺍﻻﺴـﺘﻴﻌﺎﺒﻲ ‪ Comprehensive‬ﻓﺄﻤﻴـل‬
‫ﻓﻴﻪ ﺍﻟﻰ ﺸﺭﺡ ﺍﻻﺴﺎﺴﻴﺎﺕ ﻭﺒﻨﺎﺀ ﻗﻭﺍﻋﺩ ﻤﻌﺭﻓﻴﺔ ﻟﺘﺘﻤﻜﻥ ﻤﻥ ﺍﻻﻨﻁﻼﻕ ﻓـﻲ ﺒﺭﻤﺠـﺔ ﺍﻁـﺎﺭ ﻋﻤـل‬

‫‪.NET‬‬

‫‪ Framework‬ﻤﻥ ﺍﻭﺴﻊ ﺍﺒﻭﺍﺒﻬﺎ، ﺤﻴﺙ ﻴﻤﻜﻨﻙ ﺍﻋﺘﺒﺎﺭ ﺍﻥ ﻜل ﻓﺼل ﻤﻥ ﻓﺼـﻭل ﻫـﺫﺍ ﺍﻟﻜﺘـﺎﺏ ﻤﻘﺩﻤـﺔ ﺍﻭ‬
‫ﻤﺩﺨل ﺍﻟﻰ ﺍﺴﺘﺨﺩﺍﻡ ﺘﻘﻨﻴﺔ ﻤﻥ ﺘﻘﻨﻴﺎﺕ ﺍﻁﺎﺭ ﻋﻤل ‪ ،.NET Framework‬ﻭﻴﺒﻘﻰ ﺍﻻﻤﺭ ﻓـﻲ ﺍﻟﻨﻬﺎﻴـﺔ ﻋﻠﻴـﻙ‬

‫ﻟﺘﺘﻌﻤﻕ ﻭﺘﺘﺨﺼﺹ ﻓﻲ ﺍﻟﻤﺠﺎل ﺍﻟﺫﻱ ﺘﺭﻴﺩﻩ ﺒﻨﻔﺴﻙ.‬

‫ﻣﺎذا ﻋﻦ ﻣﺒﺮﻣﺠﻲ 6‪Visual Basic 1Î‬؟‬

‫ﺤﺴﻨﺎ، ﺩﻋﻨﻲ ﻫﻨﺎ ﺍﺨﺎﻁﺏ ﺘﻠﻙ ﺍﻟﻔﺌﺔ ﻤﻥ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﻋﺸﺎﻕ ﺍﻟﻨﻐﻤﺔ ﺍﻟﺭﻨﺎﻨـﺔ ‪ .Visual Basic‬ﺍﻟﻌﻼﻗـﺔ ﺒـﻴﻥ‬
‫‪ Visual Basic .NET‬ﻭ ﺍﻻﺼﺩﺍﺭﺍﺕ ﺍﻟﺴﺎﺒﻘﺔ 6>-1 ‪ Visual Basic‬ﻻ ﺘﻜﺎﺩ ﺍﻥ ﺘﻜﻭﻥ ﺍﻻ ﻋﻼﻗﺔ ﺘﺸـﺎﺒﻪ‬

‫ﺍﺴﻤﺎﺀ، ﻓﻬﻲ ﻤﺸﺭﻭﻉ ﺘﺴﻭﻴﻘﻲ ﺍﻜﺜـﺭ ﻤﻥ ﻤـﺎ ﻫـﻭ ﺘﻁـﻭﻴﺭ ﻟﻠﻐـﺔ ﺍﻟﺒﺭﻤﺠـﺔ ﺍﻟﻤﺤﺘﻜــﺭﺓ ﻤــﻥ ﻗﺒـل‬
‫‪ .Microsoft‬ﺤﻴﺙ ﺍﻥ ﺍﻟﻀﺭﻴﺒﺔ ﺍﻟﺘﻲ ﻜﺎﻨﺕ ﺴﺘﻜﻠﻑ ﻤﺸﺭﻭﻉ ‪ Microsoft .NET‬ﻫﻭ ﺍﻨﺘﺎﺝ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠـﺔ‬

‫ﺍﻟﺠﺩﻴﺩﺓ ‪ Visual C# .NET‬ﻭﺍﻻﺴﺘﻐﻨﺎﺀ ﻋﻥ ﺍﻟﻤﻼﻴﻴﻥ ﻤﻥ ﻤﺒﺭﻤﺠﻲ ‪ .Visual Basic‬ﺍﻨﺘﺎﺝ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠـﺔ‬
‫ﺍﻟﺠﺩﻴﺩﺓ ﺍﻤﺭ ﻻ ﺒﺄﺱ ﻤﻨﻪ، ﺍﻤﺎ ﻗﻀﻴﺔ ﺍﻻﺴﺘﻐﻨﺎﺀ ﻋﻥ ﻤﻼﻴﻴﻥ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﻓﻬﻲ ﺒﺤﺎﺠﺔ –ﺒﻜل ﺘﺄﻜﻴﺩ - ﺍﻟـﻰ ﺍﻋـﺎﺩﺓ‬

‫ﻨﻅﺭ.‬

‫ﺒﻭﻀﻭﺡ ﻭﺼﺭﺍﺤﺔ ﻤﺒﺎﺸﺭﺓ، ﺍﻨﺘﺠـﺕ ‪ Microsoft‬ﻟﻐـﺔ ﺍﻟﺒﺭﻤﺠـﺔ ﺍﻟﺠﺩﻴـﺩﺓ ‪Visual C# .NET‬‬
‫ﻭﺍﻜﺎﺩ ﺍﺘﺨﻴل ﺍﺤﺩ ﺼﻨﺎﻉ ﺍﻟﻘﺭﺍﺭ ﻓﻲ ﺘﻠﻙ ﺍﻟﺸﺭﻜﺔ ﻴﻘﻭل: ﻟﻤﺎ ﻻ ﻨﻘﻭﻡ ﺒﺎﺴـﺘﺒﺩﺍل ﺼـﻴﻎ ﻟﻐـﺔ #‪ C‬ﺍﻟـﻰ ﺼـﻴﻎ‬

‫ﺸﺒﻴﻬﻪ ﺒﻠﻐﺔ ‪ ،BASIC‬ﺍﻱ –ﺒﺎﺨﺘﺼﺎﺭ - ﺍﺤﺫﻓﻭﺍ ﺍﻻﻗﻭﺍﺱ ﻤﻥ ﻋﺒـﺎﺭﺓ ﺍﻟﺸـﺭﻁ ‪ if‬ﻭﺍﺠﺒـﺭﻭﺍ ﻜﺘﺎﺒـﺔ ‪Then‬‬

‫ﺒﻌﺩﻫﺎ، ﻤﻊ ﺍﻟﻐﺎﺀ ﻀﺭﻭﺭﺓ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻔﺎﺼﻠﺔ ﺍﻟﻤﻨﻘﻭﻁﺔ ";" ﻨﻬﺎﻴﺔ ﻜل ﺴﻁﺭ.‬

‫ﺼﺤﻴﺢ ﺍﻥ ‪ Visual Basic .NET‬ﻫﻲ ﻨﺴﺨﺔ ﺒﻠﺴـﺎﻥ ﺍﺨـﺭ ﻤـﻥ ‪ ،Visual C# .NET‬ﺍﻻ ﺍﻥ‬

‫ﺍﻟﻔﺭﻭﻕ ﻁﻔﻴﻔﺔ ﻭﻻ ﺘﻜﺎﺩ ﺘﺫﻜﺭ )ﺍﺴﺘﻁﻴﻊ ﺍﻥ ﺍﺠﺯﻡ ﺍﻥ ‪ Microsoft‬ﺘﻌﻤﺩﺕ ﻭﻀﻊ ﻫﺫﻩ ﺍﻟﻔـﺭﻭﻕ ﺤﺘـﻰ ﻨﻘﺘﻨـﻊ‬

‫ﺍﻨﻬﻤﺎ ﻟﻐﺘﺎ ﺒﺭﻤﺠﺔ ﻤﺨﺘﻠﻔﺘﻴﻥ(.‬

‫ﺒﺎﻟﺭﻏﻡ ﻤﻥ ﺘﺸﺎﺒﻪ ﺍﻟﺼﻴﻎ ﺒﻴﻥ ‪ Visual Basic .NET‬ﻭﺍﻻﺼـﺩﺍﺭﺍﺕ ﺍﻟﺴـﺎﺒﻘﺔ -1 ‪Visual Basic‬‬
‫6> ﺍﻻ ﺍﻨﻪ ﻤﻥ ﺍﻟﺨﻁﺄ ﺍﻟﻜﺒﻴﺭ ﻭﺍﻟﺠﺭﻡ ﺍﻟﻌﻅﻴﻡ ﺍﻋﺘﺒﺎﺭ ‪ Visual Basic .NET‬ﺍﺼﺩﺍﺭ ﺠﺩﻴـﺩ ﻤﻨﻬـﺎ، ﺤﻴـﺙ‬
‫ﻩ‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺍﻨﻙ ﺴﺘﺘﻌﺎﻤل ﻤﻊ ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﺠﺩﻴﺩﺓ ﻜﻠﻴﺎ ﻭﻟﻴﺱ ﻟﻬﺎ ﺍﻱ ﻋﻼﻗﺔ –ﻜﻤﺎ ﺫﻜﺭﺕ - ﻤﻊ ﺍﻻﺼـﺩﺍﺭﺍﺕ ﺍﻟﺴـﺎﺒﻘﺔ ﻤـﻥ‬
‫‪ .Visual Basic‬ﻟﺫﻟﻙ، ﺘﻘﺒل ﻨﺼﻴﺤﺘﻲ ﻫﺫﻩ ﻗﺒل ﺍﻥ ﺘﻌﺎﻨﻲ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﻤﺘﺎﻋﺏ –ﻜﻤﺎ ﻋﺎﻨﻴـﺕ ﺍﻨـﺎ - ﻭﺍﻨﺴـﻰ‬
‫ﻜل ﻤﺎ ﺘﻌﻠﻤﺘﻪ ﺴﺎﺒﻘﺎ ﻓﻲ ﺍﻻﺼﺩﺍﺭﺍﺕ ﺍﻟﻘﺩﻴﻤﺔ ﻤﻥ ‪ ،Visual Basic‬ﻭﻀﻊ ﻓﻲ ﻋـﻴﻥ ﺍﻋﺘﺒـﺎﺭﻙ ﺩﺍﺌﻤـﺎ ﺍﻨـﻙ‬

‫ﺘﺘﻌﺎﻤل ﻤﻊ ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﺠﺩﻴﺩﺓ ﻭﺤﺩﻴﺜﺔ ﺍﻟﻌﻬﺩ ﺍﺴﻤﻬﺎ ‪.Microsoft Visual Basic .NET‬‬

‫اﻟﻤﺼﻄﻠﺤﺎت ﺗﻌﺮﻳﺐ ام ﺗﻌﺬﻳﺐ؟‬

‫ﻻﺘﺯﺍل ﻤﺸﻜﻠﺔ ﺍﻟﻤﺼﻁﻠﺤﺎﺕ ﺍﻟﻌﺭﺒﻴﺔ ﻓﻲ ﺭﻤﺘﻬﺎ، ﻭﺒﻤﺎ ﺍﻨﻨﻲ ﻟﺴﺕ ﻓـﻲ ﻤﻨﺼـﺏ ﻤﺴـﺅﻭل ﻟﺘﺤﺩﻴـﺩ ﻭﺍﺨﺘﻴـﺎﺭ‬
‫ﺍﻟﺘﺭﺠﻤﺎﺕ ﺍﻟﻌﺭﺒﻴﺔ ﺍﻟﺼﺤﻴﺤﺔ ﻟﻠﻤﺼﻁﻠﺤﺎﺕ ﺍﻻﺠﻨﺒﻴﺔ، ﻓﺫﻟﻙ ﻴﻌﻨـﻲ ﺤﺭﻴﺘـﻲ ﻓـﻲ ﺍﺨﺘﻴـﺎﺭ ﻤـﺎ ﺍﺭﺍﻩ ﻤﻨﺎﺴـﺒﺎ‬
‫ﻭﺭﻓﺽ ﻤﺎ ﻻ ﻴﻨﺎﺴﺒﻨﻲ.‬

‫ﻭﺠﻬﺔ ﻨﻅﺭﻱ ﺍﻟﺸﺨﺼﻴﺔ ﺤﻭل ﺘﺭﺠﻤﺔ ﺍﻟﻤﺼﻁﻠﺤﺎﺕ ﺘﺘﻤﺤﻭﺭ ﺤﻭل ﺍﺨﺘﻴﺎﺭ ﺍﻟﻜﻠﻤـﺔ ﺍﻻﻜﺜـﺭ ﺸـﻌﺒﻴﺔ ﺃﻭ‬

‫ﺍﻟﺘﻲ ﺘﻤﻴل ﺍﻟﻰ ﺘﻭﻀﻴﺢ ﺍﻟﻤﻌﻨﻰ ﺍﻟﺘﻘﻨﻲ ﻭﻟﻴﺱ ﺍﻟﻤﻌﻨﻰ ﺍﻟﺤﺭﻓﻲ، ﻟﺩﻴﻙ ﺍﻟﻜﻠﻤﺔ ‪ Help‬ﻤـﺜﻼ ﻭﺍﻟﺘـﻲ ﺘﺘـﺭﺠﻡ –‬

‫ﺒﺸﻜل ﺼﺤﻴﺢ - ﺍﻟﻰ "ﻤﺴﺎﻋﺩﺓ"، ﻭﻟﻜﻨﻲ ﻓﻀﻠﺕ ﺍﺨﺘﻴﺎﺭ ﺍﻟﻤﺼﻁﻠﺢ "ﺘﻌﻠﻴﻤﺎﺕ" ﻟﺸـﻌﺒﻴﺘﻪ ﺒـﻴﻥ ﻤﺴـﺘﺨﺩﻤﻲ ﻨﻅـﻡ‬
‫‪ .Windows‬ﻤﻥ ﻨﺎﺤﻴﺔ ﺍﺨﺭﻯ، ﻟﺩﻴﻙ ﺍﻟﻤﺼﻁﻠﺢ ‪ Overloading‬ﻭﺍﻟﺫﻱ ﺘﺘﺭﺠﻤﻪ ﺍﻟﻜﺘﺏ ﺍﻟﻌﺭﺒﻴـﺔ "ﺒﺎﻟﺘﺤﻤﻴـل‬

‫ﺍﻟﺯﺍﺌﺩ"، ﻭﻫﻭ ﺘﻌﺒﻴﺭ ﻟﻡ ﺍﺴﺘﻁﻊ ﺘﻘﺒﻠﻪ ﻻﻤﻥ ﺒﻌﻴﺩ ﻭﻻ ﻤﻥ ﻗﺭﻴﺏ، ﻓـﻼ ﻴـﻭﺤﻲ ﻤﻌﻨـﺎﻩ ﺒﺎﻟﻬـﺩﻑ ﻤﻨـﻪ، ﻭﻜـﺎﻥ‬
‫ﺍﺨﺘﻴﺎﺭﻱ ﻟﻠﺘﻌﺒﻴﺭ "ﺍﻋﺎﺩﺓ ﺍﻟﺘﻌﺭﻴﻑ" ﻫﻭ ﺍﻻﻨﺴﺏ ﻭﺍﻻﻓﻀل ﻟﻠﺘﺭﺠﻤﺔ ﺍﻟﺘﻘﻨﻴﺔ ﻟﻪ.‬
‫ﻤﻊ ﺫﻟﻙ، ﻗﺩﻤﺕ ﺍﻻﻤﺭ ﻓﻲ ﺍﻟﺒﺩﺍﻴﺔ ﻭﺍﻟﻨﻬﺎﻴﺔ ﻟﻙ ﺍﻴﻬﺎ ﺍﻟﻘﺎﺭﺉ ﺍﻟﻌﺯﻴﺯ ﻻﺨﺘﻴﺎﺭ ﺍﻟﻤﺼﻁﻠﺤﺎﺕ ﺍﻟﺘﻲ ﺘﻨﺎﺴـﺏ‬

‫ﺘﻭﺠﻬﺎﺘﻙ ﺍﻟﻠﻐﻭﻴﺔ، ﻓﻼ ﺍﻜﺎﺩ ﺍﺫﻜﺭ ﻤﺼﻁﻠﺢ ﺍﻻ ﻭﺍﺭﻓـﻕ ﺍﻟﻤﻘﺎﺒـل ﺍﻻﻨﺠﻠﻴـﺯﻱ ﻟـﻪ ﻤـﻥ ﻤﺴـﺘﻨﺩﺍﺕ ‪.NET‬‬
‫‪ ،Documentation‬ﻭﺍﻥ ﻜﺎﻨﺕ ﺍﺨﺘﻴﺎﺭﺍﺘﻲ ﻻ ﺘﻨﺎﺴﺏ ﺘﻭﺠﻬﺎﺘﻙ ﺍﻟﻠﻐﻭﻴـﺔ، ﻓـﻴﻤﻜﻥ ﺍﻟﺸـﻁﺏ ﻋﻠـﻰ ﺍﻟﻜﻠﻤـﺔ‬

‫ﻭﻜﺘﺎﺒﺔ ﻤﺎ ﺘﺭﻴﺩ ﺒﺩﺍﻟﻬﺎ.‬

‫ﻣﺎذا ﻳﻘﺪم ﻟﻚ هﺬا اﻟﻜﺘﺎب؟‬
‫ﺩﻋﻨﺎ ﻨﻀﻊ ﺍﻟﻨﻘﺎﻁ ﻋﻠﻰ ﺍﻟﺤﺭﻭﻑ، ﻭﻨﻜﻭﻥ ﻭﺍﻗﻌﻴﻥ ﻗﺩﺭ ﺍﻻﻤﻜﺎﻥ، ﻓﻘﺒل ﺍﻥ ﺘﻭﺠﻪ ﻟﻲ ﺍﻟﻨﻘﺩ ﺤﻭل ﻗﺼـﻭﺭﻱ ﻓـﻲ‬
‫ﺫﻜﺭ ﻤﺤﺘﻭﻴﺎﺕ ﺍﻁﺎﺭ ﻋﻤل ‪ ،.NET Framework‬ﻋﻠﻴﻙ ﻤﻌﺭﻓﺔ ﺍﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻟﻴﺱ ﻤﺭﺠﻌﺎ ﻤـﻥ ﻤﺭﺍﺠـﻊ‬
‫‪ ،MSDN‬ﻓﻼ ﺘﺘﻭﻗﻊ ﻤﻨﻲ ﺸﺭﺡ ﻜل ﺸﺊ ﻭﺫﻜﺭ ﻜﺎﻓﺔ ﺍﻟﺘﻔﺎﺼﻴل ﻋﻥ ﺍﻟﻤﻭﺍﻀﻴﻊ ﺍﻟﺘﻲ ﺘﻁﺭﻗـﺕ ﻟﻬـﺎ، ﻓﺎﻨـﻙ‬

‫ﺘﺨﺎﻁﺏ ﺸﺨﺹ ﻴﻜﺘﺏ ﺒﻌﺸﺭﺓ ﺍﺼﺎﺒﻊ ﻓﻘﻁ، ﻭﻤﻥ ﻏﻴﺭ ﻤﻨﻁﻘﻲ ﻤﻘﺎﺭﻨﺔ ﻤﺠﻬﻭﺩﻩ ﺒﻤﺠﻬﻭﺩ ﺍﻻﻑ ﺍﻟﻤﻭﻅﻔﻴﻥ ﻓـﻲ‬

‫ﺸﺭﻜﺔ ‪ .Microsoft‬ﻭﺍﻥ ﻜﻨﺕ ﺸﺨﺹ ﺘﻘﺩﺭ ﺍﻟﻜﻡ ﺍﻟﻌﺩﺩﻱ ﻋﻠﻰ ﺍﻟﻜﻴﻑ ﺍﻟﻤﻌﻠﻭﻤﺎﺘﻲ، ﻓﻴﺅﺴﻔﻨﻲ ﺍﺨﺒـﺎﺭﻙ ﺒـﺎﻥ‬
‫ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻟﻴﺱ ﻤﻨﺎﺴﺏ ﻟﻙ.‬

‫ﺍﺫﺍ ﻫل ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﺒﻬﺫﺍ ﺍﻟﺴﻭﺀ؟ ﻓﻲ ﺍﻟﺤﻘﻴﻘﺔ ﺴﺘﻜﻭﻥ ﺸﻬﺎﺩﺘﻲ –ﺒﻜل ﺘﺎﻜﻴـﺩ - ﻤﺠﺭﻭﺤـﺔ ﺍﻥ ﻤﺩﺤﺘـﻪ،‬
‫ﹰ‬

‫ﻭﻟﻜﻥ ﺩﻋﻨﻲ ﺍﻋﺭﺽ ﻟﻙ ﻤﺎﺫﺍ ﺴﺘﺠﺩ ﺒﻴﻥ ﺜﻨﺎﻴﺎ ﺍﻟـ 055 ﺼﻔﺤﺔ ﻭﺍﻟﻤﻜﻭﻨﺔ ﻟﻬﺫﺍ ﺍﻟﻜﺘﺎﺏ:‬
‫ﺍﺴﺎﺴﻴﺎﺕ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ‪ Visual Basic .NET‬ﻤﻥ ﺍﻟﺼﻔﺭ ﺘﺒﺩﺃ ﺒﻌﺭﺽ ﻜﻴﻔﻴﺔ ﻜﺘﺎﺒﺔ ﺍﻭل ﺒﺭﻨـﺎﻤﺞ‬

‫ﻟﻙ، ﻤﻊ ﺸﺭﺡ ﺍﻟﺼﻴﻎ ﻭﺍﻟﻌﺒﺎﺭﺍﺕ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻓﻲ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ﻜﺠﻤل ﺍﻟﺸﺭﻁ، ﺍﻟﺘﻔﺭﻉ، ﻭﺍﻟﺘﻜﺭﺍﺭ. ﺒﺎﻻﻀـﺎﻓﺔ‬
‫ﺍﻟﻰ ﻨﻅﺭﺓ ﻜﺎﺌﻨﻴـﺔ ﺍﻟﺘﻭﺠـﻪ ‪ OOP‬ﻭﻁﺭﻴﻘـﺔ ﺘﻌﺭﻴـﻑ ﺍﻟﻔﺌـﺎﺕ ‪ Classes‬ﻻﻨﺸـﺎﺀ ﺍﻟﻜﺎﺌﻨـﺎﺕ ‪،Objects‬‬

‫ﻭﺍﻻﺴﺘﺨﺩﺍﻡ ﺍﻻﻤﺜل ﻟﻬﺎ ﻟﺘﻁﺒﻴﻕ ﻤﺒﺎﺩﺉ ﺍﻟﻭﺭﺍﺜﺔ ‪ Inheritance‬ﻭﺘﻌﺩﺩ ﺍﻟﻭﺍﺠﻬﺎﺕ ‪.Polymorphism‬‬
‫و‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻋﺭﺽ ﺴﺭﻴﻊ ﻟﻤﻜﺘﺒﺔ ﻓﺌﺎﺕ ﺍﻁﺎﺭ ﻋﻤل ‪ .NET Framework‬ﺍﻥ ﺍﺭﺩﺕ ﺍﺨﺫ ﺠﻭﻟﺔ ﺴﺭﻴﻌﺔ ﺤـﻭل‬
‫ﻤﻜﺘﺒﺔ ﻓﺌﺎﺕ ﺍﻁﺎﺭ ﻋﻤل ‪ ،.NET Framework‬ﻓﺴﺘﺠﺩ ﻤﻠﺨﺼﺎ ﻟﻬﺎ ﻫﻨﺎ، ﺤﻴﺙ ﺍﻋﺭﺽ ﻟﻙ ﻤﺠﻤﻭﻋـﺔ ﻤـﻥ‬

‫ﺍﻟﻔﺌﺎﺕ ﺍﻻﺴﺎﺴﻴﺔ، ﻭﻓﺌﺎﺕ ﺍﺨﺭﻯ ﺘﺴﺘﺨﺩﻤﻬﺎ ﻻﻨﺠﺎﺯ ﻤﻬﺎﻡ ﻤﻌﻴﻨﺔ: ﻜﺎﺌﻨـﺎﺕ ﺍﻻﺴـﺘﺜﻨﺎﺀﺍﺕ ‪ ،Exceptions‬ﺩﺨـل‬
‫ﺨﺭﺝ ﺍﻟﻤﻠﻔﺎﺕ ‪ ،File IO‬ﺘﺴﻠﺴل ﺍﻟﻜﺎﺌﻨـﺎﺕ ‪ ،Object Serialization‬ﻤﺴـﺎﺭﺍﺕ ﺍﻟﺘﻨﻔﻴـﺫ ‪،Threading‬‬
‫ﻁﺭﻴﻘﺔ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻤﺠﻤﻌﺎﺕ ‪ Assemblies‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﻓﺌﺎﺕ ﺍﻻﻨﻌﻜﺎﺱ ‪.Reflection Classes‬‬

‫ﺍﺴﺎﺴﻴﺎﺕ ﺘﻁﻭﻴﺭ ﺘﻁﺒﻴﻘﺎﺕ ‪ Windows Application‬ﺒﺎﺴﺘﻴﻌﺎﺏ ﻓﻜـﺭﺓ ﻨﻤـﺎﺫﺝ ‪Windows‬‬
‫‪ Forms‬ﻭﻁﺭﻴﻘﺔ ﻭﺭﺍﺜﺘﻬﺎ، ﻜﻤﺎ ﺍﺨﺫﻙ ﻓﻲ ﺠﻭﻟﺔ ﺴﺭﻴﻌﺔ ﺤﻭل ﻤﻌﻅﻡ ﺍﻻﺩﻭﺍﺕ ‪ Controls‬ﻭﺍﻟﻐﺭﺽ ﻤﻨﻬـﺎ،‬

‫ﺒﺎﻻﻀﺎﻓﺔ ﺍﻟﻰ ﺘﻁﺒﻴﻕ ﺘﻘﻨﻴﺔ ﺍﻟﻤﺭﺁﺓ ‪ Mirroring‬ﻋﻠﻴﻬﺎ. ﺜﻡ ﺍﺨﺼـﺹ ﻓﺼـل ﻜﺎﻤـل ﻴﻌﺘﺒـﺭ ﻤـﺩﺨﻠﻙ ﺍﻟـﻰ‬
‫ﺍﺴﺘﺨﺩﺍﻡ ﺘﻘﻨﻴﺔ +‪ GDI‬ﻭﻁﺭﻴﻘﺔ ﺍﻟﺭﺴﻡ ﻭﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺼﻭﺭ ﻭﺍﻟﻤﺨﺭﺠﺎﺕ ﺍﻟﻨﺼﻴﺔ. ﺍﻟﻤﺯﻴـﺩ ﺍﻴﻀـﺎ، ﺍﻋـﺭﺽ‬

‫ﻟﻙ ﻁﺭﻴﻘﺔ ﺘﻜﻭﻴﻥ ﺍﺩﻭﺍﺓ ﺨﺎﺼﺔ ‪ Custom Controls‬ﻭﺒﻨﺎﺀ ﺨﺩﻤﺎﺕ ‪.Windows Services‬‬
‫ﺍﺴﺘﺨﺩﺍﻡ ‪ ADO.NET‬ﻟﺒﺭﻤﺠﺔ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﺸﺭﺡ ﻟﻔﻜﺭﺓ ﺍﻟﻭﻀـﻊ ﺍﻟﻤﺘﺼـل‬

‫‪Connected‬‬

‫‪ Mode‬ﻭﺍﻟﻭﻀﻊ ﺍﻟﻤﻨﻔﺼل ‪ ،Disconnected Mode‬ﻭﺫﻟﻙ ﺒﺫﻜﺭ ﺍﻟﻔﺌﺎﺕ ﺍﻟـﻼﺯﻡ ﺍﺴـﺘﺨﺩﺍﻤﻬﺎ ﻓـﻲ ﻜـﻼ‬
‫ﺍﻟﻭﻀﻌﻴﻥ، ﻜﻤﺎ ﺍﺘﺤﺩﺙ ﻋﻥ ﻁﺭﻴﻘﺔ ﺭﺒﻁﻬﺎ ﺒﺎﻻﺩﻭﺍﺕ ﻭﺘﻜﺎﻤل ﺘﻘﻨﻴﺔ ‪ ADO.NET‬ﻤﻊ ‪.XML‬‬
‫ﻤﻘﺩﻤﺔ ﻟﺒﺭﻤﺠﺔ ‪ ASP.NET‬ﻻﻋﺭﺽ ﻓﻴﻪ ﻓﻠﺴﻠﻔﺔ ﻋﻤـل ﺼـﻔﺤﺎﺕ ﺍﻟﺨـﺎﺩﻡ ‪ ASP.NET‬ﻭﺒﻨـﺎﺀ‬

‫ﻤﻭﺍﻗﻌﻙ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻟﻬﺫﻩ ﺍﻟﺘﻘﻨﻴﺔ، ﻜﻤﺎ ﺍﻋﺭﺽ ﻟﻙ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﻜﺎﺌﻨﺎﺕ ﺍﻟﺘـﻲ ﻻ ﻏﻨـﻰ ﻋﻨﻬـﺎ ﻓـﻲ ﺍﻏﻠـﺏ‬
‫ﻤﺸﺎﺭﻴﻊ ‪ ،ASP.NET‬ﻭﺍﺨﺘﻡ ﺍﻟﻜﺘﺎﺏ ﺒﺎﻟﺘﺤﺩﺙ ﻋﻥ ﺨـﺩﻤﺎﺕ ﻭﻴـﺏ ‪ Web Services‬ﻭﻁﺭﻴﻘـﺔ ﺍﻨﺠﺎﺯﻫـﺎ‬

‫ﻭﺍﺴﺘﺨﺩﺍﻤﻬﺎ.‬

‫اﻟﻘﺮص اﻟﻤﺪﻣﺞ ‪CD-ROM‬‬

‫ﻴﺤﺘﻭﻱ ﺍﻟﻘﺭﺹ ﺍﻟﻤﺩﻤﺞ ﺍﻟﻤﺭﻓﻕ ﻤﻊ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻋﻠﻰ ﺠﻤﻴﻊ ﺍﻟﺸﻴﻔﺭﺍﺕ ﺍﻟﻤﺼﺩﺭﻴﺔ ﺍﻟﺘﻲ ﺍﻀـﻴﻑ ﺍﻟﺭﻤـﺯ‬
‫ﻓﻲ ﺍﻋﻼﻫﺎ، ﻤﻘﺴﻤﺔ ﺍﻟﻰ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﻤﺠﻠﺩﺍﺕ ﺘﻤﺜل ﺭﻗﻡ ﺍﻟﻔﺼل ﺍﻟﺫﻱ ﺴﻁﺭﺕ ﻓﻲ ﺍﻟﺸﻴﻔﺭﺓ. ﻜﻤـﺎ ﺘﻌﻤـﺩﺕ‬

‫ﺍﻀﺎﻓﺔ ﻤﻠﻔﺎﺕ ﺼﻭﺭ )ﻤﻥ ﺍﻟﻨﻭﻉ ‪ (JPG‬ﺘﻤﺜل ﺍﻟﺼﻭﺭ ﻭﺍﻻﺸﻜﺎل ﺍﻟﺘﻭﻀـﻴﺤﻴﺔ ﺍﻟﻤﻌﺭﻭﻀـﺔ ﻓـﻲ ﺍﻟﻔﺼـﻭل،‬
‫ﻭﺫﻟﻙ ﺨﺸﻴﺔ ﻋﺩﻡ ﻭﻀﻭﺤﻬﺎ ﺒﻴﻥ ﺼﻔﺤﺎﺕ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ. ﻜﻤﺎ ﻴﻤﻜﻨﻙ ﺍﻴﺠـﺎﺩ ﺍﻟﻤﻠـﻑ ‪ArabicConsole.DLL‬‬

‫ﻭﺍﻟﺫﻱ ﻁﻭﺭﺘﻪ ﻟﻤﺤﺎﻜﺎﺓ ﺍﻟﻜﺎﺌﻥ ‪ Console‬ﻓﻲ ﺍﻟﺩﻟﻴل ﺍﻟﺠﺫﺭﻱ ﻟﻠﻘﺭﺹ -ﺴﺎﺨﺒﺭﻙ ﺒـﻪ ﻻﺤﻘـﺎ ﻓـﻲ ﺍﻟﻔﺼـل‬
‫ﺍﻻﻭل ﺘﻌﺭﻑ ﻋﻠﻰ ‪.Visual Basic .NET‬‬

‫ﺻﻔﺤﺔ اﻟﻜﺘﺎب ﻋﻠﻰ اﻻﻧﺘﺮﻧﺖ‬
‫ﻻ ﺍﻭﺩ ﺍﻨﻬﺎﺀ ﻋﻼﻗﺘﻲ ﻤﻌﻙ ﻤﻊ ﺍﻟﺼﻔﺤﺔ ﺍﻻﺨﻴﺭﺓ ﻤﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ، ﺒل ﺴﻴﻜﻭﻥ ﺸﺭﻑ ﻟﻲ ﺘﻤﺩﻴﺩﻫﺎ ﺍﻟـﻰ ﻓﺘـﺭﺍﺕ‬
‫ﺍﻁﻭل. ﻴﻤﻜﻨﻙ ﻋﺯﻴﺯ ﺍﻟﻘﺎﺭﺉ ﺍﺼﻁﻴﺎﺩﻱ ﻋﻠﻰ ﺸﺒﻜﺔ ﺍﻻﻨﺘﺭﻨﺕ ﺍﻤـﺎ ﻋـﻥ ﻁﺭﻴـﻕ ﻤﺭﺍﺴـﻠﺘﻲ ﻋﻠـﻰ ﺒﺭﻴـﺩﻱ‬
‫ﺍﻻﻟﻜﺘﺭﻭﻨﻲ ﺍﻭ ﻤﻥ ﺨﻼل ﺯﻴﺎﺭﺓ ﺼﻔﺤﺔ ﺍﻟﻜﺘﺎﺏ ﺍﻥ ﻜﻨﺕ ﺘﺭﻏـﺏ ﻓـﻲ ﺍﻟﺤﺼـﻭل ﻋﻠـﻰ ﺍﺨـﺭ ﺍﻟﺘﺤـﺩﻴﺜﺎﺕ‬

‫ﻭﺘﺼﺤﻴﺢ ﺍﻻﺨﻁﺎﺀ ﺍﻟﻤﺘﻌﻠﻘﺔ ﺒﻪ، ﻭﺫﻟﻙ ﺒﺘﻭﺠﻴﻪ ﻤﺘﺼﻔﺤﻙ ﺍﻟﻰ ﺍﻟﻌﻨﻭﺍﻥ ﺍﻟﺘﺎﻟﻲ:‬

‫‪http://www.dev4arabs.com/ar‬‬
‫ز‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫اﻻﺧﻄﺎء )هﺎم ﺟﺪا(‬

‫ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﺍﻟﻜﻤﺎل ﺸﺊ ﻻ ﻴﺘﻡ ﺍﻻ ﺒﺎﻟﻘﺩﺭﺓ ﺍﻻﻟﻬﻴﺔ، ﻭﺍﻟﻌﻤل ﺍﻟﺫﻱ ﺍﻤﺎﻡ ﻋﻴﻨﻴﻙ ﺠﻬﺩ ﺒﺸـﺭﻱ ﻤﻌـﺭﺽ ﺒﻨﺴـﺒﺔ‬
‫ﻜﺒﻴﺭﺓ ﻟﻠﺨﻁﺄ، ﻴﻬﻤﻨﻲ ﺠﺩﺍ ﺍﻟﺘﻘﻠﻴل ﻤﻥ ﺍﻻﺨﻁﺎﺀ ﻓﻲ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ، ﺤﺘـﻰ ﻴﻜـﻭﻥ ﻤﺭﺠﻌـﺎ ﻋﺭﺒﻴـﺎ ﺴـﻠﻴﻤﺎ ﻤـﻥ‬

‫ﺍﻟﺸﻭﺍﺌﺏ. ﻓﻲ ﺤﺎﻟﺔ ﺍﻟﻌﺜﻭﺭ ﻋﻠﻰ ﺍﻱ ﺨﻁﺄ )ﺴﻭﺍﺀ ﻟﻐﻭﻱ ﺍﻭ ﺘﻘﻨﻲ(، ﺒﺭﺠﺎﺀ ﺍﺒﻼﻏﻲ ﻓﻭﺭﺍ ﻋـﻥ ﺍﻟﺨﻁـﺄ ﻭﺭﻗـﻡ‬
‫ﺍﻟﺼﻔﺤﺔ ﺍﻟﺫﻱ ﻭﻗﻊ ﻓﻴﻪ، ﻭﺒﻬﺫﺍ ﺘﺴﺩﻱ ﻟﻲ ﺨﺩﻤﺔ ﺴﺎﻜﻭﻥ ﺸﺎﻜﺭﺍ ﻭﻤﻘﺩﺭﺍ ﻟﻬﺎ.‬

‫آﻠﻤﺔ اﺧﻴﺮة‬

‫ﺍﺨﻲ ﺍﻟﻤﺒﺭﻤﺞ ﺍﻟﻌﺭﺒﻲ ﻤﻥ ﺍﻟﻤﺤﻴﻁ ﺍﻟﻰ ﺍﻟﺨﻠﻴﺞ، ﺒﻭﺩﻱ ﺘﻭﻀﻴﺢ ﻨﻘﻁﺔ ﻀﺭﻭﺭﻴﺔ ﺘﺘﻤﺤﻭﺭ ﺤﻭل ﻤﺅﻟـﻑ ﺍﻟﻜﺘـﺎﺏ‬

‫ﺍﻟﺫﻱ ﺘﻘﺭﺃﻩ ﺍﻻﻥ. ﺼﺤﻴﺢ ﺍﻥ ﻓﻥ ﺍﻟﻜﺘﺎﺒﺔ ﺒﻌﻴﺩ ﻜل ﺍﻟﻤﺒﻌﺩ ﻋﻥ ﻤﺠﺎل ﻋﻤﻠﻲ ﺍﻻ ﺍﻨﻪ ﻋﻠﻴﻙ ﻤﻌﺭﻓﺔ ﺍﻨﻨـﻲ ﻤﺒـﺭﻤﺞ‬
‫ﻭﻟﺴﺕ ﻜﺎﺘﺏ، ﻓﻠﺴﺕ ﻤﻥ ﺍﻟﺫﻴﻥ ﻟﺩﻴﻬﻡ ﺍﻋﻤﺩﺓ ﻓﻲ ﺍﻟﺼﺤﻑ ﻭﺍﻟﻤﺠﻼﺕ ﻭﻴﻬـﻭﻯ ﻜﺘﺎﺒـﺔ ﺍﻟﻤﻘـﺎﻻﺕ، ﺒـل ﺍﻗـﻭﻡ‬

‫ﺒﻜﺘﺎﺒﺔ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ ﻭﺍﻟﺒﺭﺍﻤﺞ ﻟﻤﺨﺘﻠﻑ ﺍﻟﻘﻁﺎﻋﺎﺕ. ﻜﻤﺎ ﻟـﺩﻱ ﺍﻟﻜﺜﻴـﺭ ﻤـﻥ ﺍﻟﻌﻼﻗـﺎﺕ ﺒـﻴﻥ ﻋﻤﺎﻟﻘـﺔ‬
‫ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﻓﻲ ﺍﻨﺤﺎﺀ ﺍﻟﻤﻌﻤﻭﺭﺓ ﻭﻗﺩ ﺍﺴﺘﻔﺩﺕ ﺍﻟﻜﺜﻴﺭ ﻭﺍﻟﺸﺊ ﺍﻟﻜﺒﻴﺭ ﻤﻥ ﺍﺤﺘﻜﺎﻜﻲ ﻤﻌـﻪ. ﻭﺍﻋﺘﻘـﺩ –ﺒـل ﺍﻜـﺎﺩ‬

‫ﺍﺠﺯﻡ - ﺍﻨﻙ ﻟﻡ ﺘﻘﺘﻨﻲ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻟﺘﺘﻌﻠﻡ ﻓﻥ ﺍﻟﺒﻼﻏﺔ ﺍﻭ ﺍﻻﺴﺘﻤﺘﺎﻉ ﺒﺎﻟﺘﻌﺎﺒﻴﺭ ﺍﻟﻠﻐﻭﻴﺔ، ﺒـل ﺘﺭﻴـﺩ ﺍﻥ ﺘـﺘﻌﻠﻡ ﻟﻐـﺔ‬
‫ﺒﺭﻤﺠﺔ ﺍﺴﻤﻬﺎ ‪ .Visual Basic .NET‬ﻟﺫﻟﻙ، ﺤﺎﻭل ﺘﺠﺎﻫل ﻗﺩﺭ ﺍﻻﻤﻜـﺎﻥ ﺘﻌـﺎﺒﻴﺭﻱ ﺍﻟﻠﻐﻭﻴـﺔ ﺍﻟﺭﻜﻴﻜـﺔ،‬
‫ﻭﻀﻌﻑ ﺍﺴﻠﻭﺒﻲ ﺍﻟﺒﻼﻏﻲ ﻭﺍﻟﻜﺘﺎﺒﻲ، ﻭﻟﻨﺠﻌل ﻟﻐﺔ ﺍﻟﺸـﻴﻔﺭﺍﺕ ﺍﻟﻤﺼـﺩﺭﻴﺔ ‪ Source Codes‬ﻫـﻲ ﺍﻟﻘﺎﺴـﻡ‬
‫ﺍﻟﻤﺸﺘﺭﻙ ﺒﻴﻨﻨﺎ.‬
‫ﺍﻟﻔﺘﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ ﺍﻟﺘﻲ ﻗﻀﻴﺘﻬﺎ ﻓﻲ ﻜﺘﺎﺒﺔ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻜﺎﻨﺕ ﻁﻭﻴﻠﺔ ﺒﻌﺽ ﺍﻟﺸﺊ ﻭﺍﻟﻭﻗـﺕ ﻗﺼـﻴﺭ ﺠـﺩﺍ،‬

‫ﻭﻟﻡ ﺍﺴﺘﻁﻊ –ﺒﺼﺭﺍﺤﺔ ﺸﺩﻴﺩﺓ - ﻜﺘﺎﺒﺔ ﻜل ﺍﻟﺘﻔﺎﺼﻴل ﺍﻟﺘﻲ ﻭﺩﺩﺕ ﺫﻜﺭﻫﺎ ﻓﻲ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ، ﻟﺫﻟﻙ ﻭﻀـﻌﺕ ﻓـﻲ‬
‫ﻋﻴﻥ ﺍﻋﺘﺒﺎﺭﻱ ﻗﺩﺭﺓ ﺍﻟﻘﺎﺭﺉ ﻋﻠﻰ ﺍﻟﺘﻌﻠﻡ ﺍﻟﺫﺍﺘﻲ، ﺤﻴﺙ ﻜﺎﻥ ﻫﺩﻓﻲ ﺍﻋﻁﺎﺌﻙ ﻤﻔﺘـﺎﺡ ﻭﻤـﺩﺨل ﻟﻤﺴـﺎﺌل ﻋﺩﻴـﺩﺓ‬

‫ﻭﺘﺭﻜﺕ ﺍﻟﺒﺎﻗﻲ ﻋﻠﻴﻙ ﻟﻠﺒﺤﺙ ﻋﻥ ﺍﻟﺘﻔﺎﺼﻴل ﺍﻻﺨﺭﻯ ﺴﻭﺍﺀ ﻓـﻲ ﻤﻭﺍﻗـﻊ ﺍﻻﻨﺘﺭﻨـﺕ ﺍﻭ ﻤﺴـﺘﻨﺩﺍﺕ ﻭﻤﺭﺍﺠـﻊ‬
‫‪ .NET Documentation‬ﺍﻟﺭﺴﻤﻴﺔ.‬

‫ﺒﺭﻤﺠﺔ ﺍﻁﺎﺭ ﻋﻤل ‪ .NET‬ﺒﺎﺴﺘﺨﺩﺍﻡ ‪ Visual Basic .NET‬ﻤﺎﻫﻭ ﺍﻻ ﻤﺤﺎﻭﻟـﺔ ﺠـﺎﺩﺓ ﻟﺘـﺄﻟﻴﻑ‬

‫ﻜﺘﺎﺏ ﻋﺭﺒﻲ ﻤﻥ ﻤﺅﻟﻑ ﻋﺭﺒﻲ ﻭﻤﻭﺠﻪ ﺍﻟﻰ ﻤﺒﺭﻤﺞ ﻋﺭﺒﻲ ﻟﺘﻘﺩﻴﻡ ﻜل ﻤﺎ ﻴﺤﺘﺎﺠﻪ ﻤﻥ ﻤﻌﻠﻭﻤـﺎﺕ ﺘﻤﻜﻨـﻪ ﻤـﻥ‬
‫ﺒﻨﺎﺀ ﺘﻁﺒﻴﻘﺎﺕ ﻭﺤﻠﻭل ﻋﻤﻠﻴﺔ ﻤﻭﺠﻪ ﺍﻟـﻰ ﺍﻁـﺎﺭ ﻋﻤـل ‪ .NET Framework‬ﺒﺎﺴـﺘﺨﺩﺍﻡ ﻟﻐـﺔ ﺍﻟﺒﺭﻤﺠـﺔ‬
‫‪ ،Visual Basic .NET‬ﺒﺩﺀﺍ ﻤﻥ ﺘﻭﻀﻴﺢ ﺍﺴﺎﺴﻴﺎﺕ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠـﺔ ﻭﺍﻨﺘﻬﺎﺌـﺎ ﺒﺘﻁـﻭﻴﺭ ﺘﻁﺒﻴﻘـﺎﺕ ﻤﺨﺘﻠﻔـﺔ‬

‫ﺍﻟﻤﺠﺎﻻﺕ ﺩﺍﻋﻤﺔ ﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ. ﺍﺘﻤﻨﻰ ﺍﻥ ﺍﻜﻭﻥ ﻗﺩ ﻭﻓﻘﺕ ﻓﻲ ﻤﺤـﺎﻭﻟﺘﻲ ﻫـﺫﻩ ﻭﻗـﺩﻤﺕ ﻤـﺎ ﻴﺭﻀـﻲ ﺫﻭﻕ‬

‫ﺍﻟﻤﺒﺭﻤﺞ ﺍﻟﻌﺭﺒﻲ ... ﺤﻅﺎ ﺴﻌﻴﺩﺍ!‬
‫ﺘﺭﻜﻲ ﺍﻟﻌﺴﻴﺭﻱ‬

‫ﺍﻟﻅﻬﺭﺍﻥ – ﻓﺒﺭﺍﻴﺭ 3002‬
‫‪.turki@dev4arabs.com‬‬
‫1‬

‫اﻟﻔﺼﻞ اﻻول‬

‫ﺗﻌﺮف ﻋﻠﻰ ‪Visual Basic .NET‬‬
‫ﺒﺴﻡ ﺍﷲ ﻨﺒﺩﺃ ﻭﻋﻠﻰ ﺒﺭﻜﺘﻪ ﻨﺴﻴﺭ ﻤﻊ ﺍﻟﺠﻤﻠﺔ ‪ ،Visual Basic .NET‬ﺘﺘﻜﻭﻥ ﻫﺫﻩ ﺍﻟﺠﻤﻠـﺔ ﻤـﻥ 41 ﺤﺭﻓـﺎ‬
‫ﻭﻨﻘﻁﺔ ﻭﺍﺤﺩﺓ، ﺍﻟﺤﺭﻭﻑ ﺍﻟـ 11 ﺍﻻﻭﻟﻰ ﺘﻌﻨﻲ ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﺍﺴـﻤﻬﺎ ‪ ،Visual Basic‬ﻭﺍﻟﻨﻘﻁـﺔ ﻭﺍﻟﺤـﺭﻭﻑ‬
‫ﺍﻟﺜﻼﺙ ﺍﻻﺨﻴﺭﺓ ﺘﻌﻨﻲ ﺍﻁﺎﺭ ﻋﻤل ‪ .NET Framework‬ﻟﺫﻟﻙ، ﻴﻤﻜﻨﻨﺎ ﺍﻥ ﻨﻁﻠﻕ ﻋﻠﻰ ﻫﺫﻩ ﺍﻟﻠﻐـﺔ ‪Visual‬‬
‫‪) Basic for .NET Framework‬ﺍﻱ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ‪ Visual Basic‬ﺍﻟﻤﻭﺠﻬﻪ ﺍﻟﻰ ﺍﻁﺎﺭ ﻋﻤل ‪.NET‬‬
‫‪.(Framework‬‬
‫ﺭﺤﻠﺔ ﺍﻻﻟﻑ ﻤﻴل ﺘﺒﺩﺃ ﺒﺨﻁﻭﺓ، ﻭﺨﻁﻭﺘﻨﺎ ﺍﻻﻭﻟﻰ ﻓﻲ ﺭﺤﻠﺘﻨـﺎ ﻤـﻊ ‪ Visual Basic .NET‬ﺴـﺘﻜﻭﻥ‬

‫ﻨﻅﺭﻴﺔ ﺒﺤﺘﺔ. ﻓﻘﺒل ﺍﻥ ﺘﺒﺩﺃ ﺒﻔﺭﻗﻌﺔ ﺍﻨﺎﻤﻠﻙ ﻟﻜﺘﺎﺒﺔ ﺍﻟﺸﻴﻔﺭﺍﺕ ﻭﺒﻨﺎﺀ ﺒﺭﺍﻤﺠﻙ، ﻤﻥ ﺍﻟﺠﻴـﺩ ﺍﺨـﺫ ﻓﻜـﺭﺓ ﻤﺒﺴـﻁﺔ‬
‫ﻋﻥ ﺍﻟﺤﺭﻭﻑ ﺍﻟﺸﻬﻴﺭﺓ ‪ .NET‬ﻭﻤﻌﺭﻓﺔ ﻤﺎﺫﺍ ﺘﻌﻨﻲ ﻫﺫﻩ ﺍﻟﺤﺭﻭﻑ، ﻭﻤﺎ ﺍﻟﺫﻱ ﺘﻘﺩﻤﻪ ﻟﻙ، ﻭﻤـﺎ ﻫـﻲ ﺍﻟﺤﺎﺠـﺔ‬
‫ﺍﻟﺘﻲ ﺘﺩﻋﻭﻨﺎ –ﺃﻨﺕ ﻭﺃﻨﺎ ﻋﻠﻰ ﺍﻻﻗل - ﻟﻼﻨﺘﻘﺎل ﺍﻟﻰ ﺒﺭﻤﺠﺔ ﺍﻁـﺎﺭ ﻋﻤـل ‪ .NET Framework‬ﻭﺍﺫﺍ ﻜﻨـﺕ‬
‫ﻤﻥ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺍﻟﻤﺨﻀﺭﻤﻴﻥ، ﻓﺴﻴﻜﻭﻥ ﻫﺫﺍ ﺍﻟﻔﺼل ﻤﺼﺩﺭ ﻻﻓـﺭﺍﻍ ﺠﻤﻴـﻊ ﻤﻌﺎﻨﺎﺘـﻙ ﺍﻟﺴـﺎﺒﻘﺔ ﻤـﻊ ﻋـﺎﻟﻡ‬

‫ﺍﻟﺒﺭﻤﺠﺔ، ﺍﻤﺎ ﺍﻥ ﻜﺎﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﺍﻭل ﻜﺘﺎﺏ ﺒﺭﻤﺠﺔ ﺘﻘﺭﺃﻩ ﻓﻲ ﺤﻴﺎﺘﻙ، ﻓﺎﻋﺘﺒﺭ ﻨﻔﺴﻙ ﻤﺒﺭﻤﺞ ﻤﺤﻅـﻭﻅ ﺠـﺩﺍ‬
‫ﻟﻤﺎ ﺴﺘﻜﺘﺸﻔﻪ ﻤﻥ ﺍﻟﺘﻌﻘﻴﺩﺍﺕ ﺍﻟﺘﻲ ﻜﺎﻨﺕ ﺘﻭﺍﺠﻪ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﻗﺒل ﺘﻘﻨﻴﺔ ‪.NET‬‬

‫اﻟﺤﻴﺎة ﻗﺒﻞ ‪.NET‬‬
‫ﻟﺴﺕ ﻫﻨﺎ ﺒﺼﺩﺩ ﺘﺄﻟﻴﻑ ﻜﺘﺎﺏ ﺘﺎﺭﻴﺦ ﺍﻭ ﺍﻟﺘﺤﺩﺙ ﻋﻥ ﺒﺩﺍﻴﺎﺕ ﻅﻬﻭﺭ ﺍﻟﺤﺎﺴﺒﺎﺕ ﺍﻟﺸﺨﺼﻴﺔ، ﻓﻔـﻲ ﺫﻟـﻙ ﺍﻟـﺯﻤﻥ‬

‫ﻟﻡ ﺍﻜﻥ ﺸﻴﺌﺎ ﻤﺫﻜﻭﺭﺍ. ﻭﻟﻜﻥ ﻤﺎ ﺍﻨﺎ ﺒﺼﺩﺩﺓ ﺍﻵﻥ ﻫﻭ ﺘﻘﺩﻴﻡ ﻋﺭﺽ ﻤﻘﺘﻀﺏ ﻭﺴـﺭﻴﻊ ﻻﺴـﺎﻟﻴﺏ ﺒﻨـﺎﺀ ﺍﻟﺒـﺭﺍﻤﺞ‬
‫ﹰ‬
‫ﻤﻨﺫ ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ‪ DOS‬ﻭﺤﺘﻰ ﻟﺤﻅﺔ ﻜﺘﺎﺒﺔ ﻫﺫﻩ ﺍﻟﺴـﻁﻭﺭ، ﻭﺴـﻴﻜﻭﻥ ﺤـﺩﻴﺜﻲ ﻤﻭﺠﻬـﺎ ﻟﻤﺒﺭﻤﺠـﻲ ﻨﻅـﻡ‬
‫ﹰ‬
‫‪ Microsoft‬ﺒﺸﻜل ﺤﺼﺭﻱ.‬

‫اﻟﺒﺮﻣﺠﺔ ﺗﺤﺖ ﻧﻈﻢ ‪DOS‬‬

‫ﻜﺎﻥ ﻜل ﻤﺎﻫﻭ ﻤﻁﻠﻭﺏ ﻤﻨﻙ -ﻜﻤﺒﺭﻤﺞ - ﺍﺴﺘﺨﺩﺍﻡ ﺍﻤﺭ ‪ Input‬ﻟﻘﻨﺹ ﺍﻟﻤـﺩﺨﻼﺕ ﻤـﻥ ﺍﻟﻤﺴـﺘﺨﺩﻡ، ﻭﺍﻻﻤـﺭ‬
‫‪ Print‬ﻟﻌﺭﺽ ﺍﻟﻤﺨﺭﺠﺎﺕ ﻋﻠﻰ ﺍﻟﺸﺎﺸﺔ، ﺒﺎﻻﻀﺎﻓﺔ ﺍﻟﻰ ﺍﺴﺘﺨﺩﺍﻡ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﻌﺒﺎﺭﺍﺕ ﻟﺘﻁﺒﻴـﻕ ﺍﻟﻌﻤﻠﻴـﺎﺕ‬

‫ﺍﻟﺤﺴﺎﺒﻴﺔ. ﻜﺎﻨﺕ ﻓﻲ ﺍﻟﺤﻘﻴﻘﺔ ﺒﺭﻤﺠﺔ ﺴﻬﻠﺔ ﻭﻤﻤﺘﻌﺔ ﻟﻠﻤﺒﺭﻤﺠﻴﻥ، ﺤﺘﻰ ﺍﺼﺒﺢ ﻜل ﻤﻥ ﻫـﺏ ﻭﺩﺏ ﻴـﺩﻋﻲ ﺍﻨـﻪ‬
‫ﻤﺒﺭﻤﺞ، ﺍﻻ ﺍﻥ ﺍﻟﻨﺘﻴﺠﺔ ﻜﺎﻨﺕ ﺒﺭﺍﻤﺞ ﻤﺘﺸﺎﺒﻬﺔ، ﻻ ﺠﺩﻴﺩ ﻓﻴﻬﺎ ﻭﻻ ﺘﺴﺘﺨﺩﻡ ﺘﻘﻨﻴﺎﺕ ﺠﺩﻴﺩﺓ.‬
‫4‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺒﻌﺩ ﺫﻟﻙ، ﻅﻬﺭﺕ ﺍﻟﺤﺎﺠﺔ ﺍﻟﻰ ﺍﻟﺘﺤﻠﻴﻕ ﺍﻟﻰ ﻤﺩﻯ ﺍﺒﻌﺩ ﻤﻥ ﺍﻻﺴﻠﻭﺏ ﺍﻟﺴﺎﺒﻕ، ﻓﻜﺎﻨﺕ ﺍﻫـﺩﺍﻑ ﺍﻟﺘﺤﻠﻴـﻕ‬
‫-ﺒﺸﻜل ﻤﺒﺩﺌﻲ - ﺍﻟﺘﻔﺎﻋل ﻤﻊ ﺍﻻﺠﻬﺯﺓ ‪ Devices‬ﺍﻟﺘﻲ ﺘﺭﻜﺏ ﻓﻲ ﺍﻟﺠﻬـﺎﺯ )ﻜﺎﻟﻁﺎﺒﻌـﺔ، ﺒﻁﺎﻗـﺔ ﺍﻟﺼـﻭﺕ،‬

‫ﺍﻟﻔﺄﺭﺓ ...ﺍﻟﺦ(، ﺍﻻ ﺍﻥ ﺍﺠﻨﺤﺔ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﻓﻲ ﺫﻟﻙ ﺍﻟﻭﻗﺕ ﻜﺎﻨﺕ ﺘﻌﺘﻤﺩ ﺍﻋﺘﻤﺎﺩﺍ ﻜﻠﻴﺎ ﻋﻠـﻰ ﺒﺭﻴﻤﺠﻴـﺎﺕ ﺘﺎﺒﻌـﺔ‬
‫ﹰ ﹰ‬
‫ﺘﺴﻤﻰ ﺍﻟﻤﺸﻐﻼﺕ ‪ .Drivers‬ﻤﻌﻅﻡ ﻫﺫﻩ ﺍﻟﻤﺸﻐﻼﺕ ﻜﺎﻨﺕ ﺘﻨﺠـﺯ ﺒﻠﻐـﺔ ﺍﻟﺘﺠﻤﻴـﻊ ‪ ،Assembly‬ﻭﺘﺘﻁﻠـﺏ‬
‫ﺨﺒﺭﺓ ﻜﺒﻴﺭﺓ ﻓﻲ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻤﻌﺎﻟﺞ ﻭﻋﺘﺎﺩ ﺍﻟﻜﻤﺒﻴﻭﺘﺭ. ﻓﻠﻭ ﻗﻤﺕ ﺒﻌﻤل ﺒﺭﻨـﺎﻤﺞ ﻴﻁﺒـﻊ ﺍﻟﻨﺘـﺎﺌﺞ ﻋﻠـﻰ ﻭﺭﻕ‬
‫ﺍﻟﻁﺎﺒﻌﺔ، ﻓﻌﻠﻴﻙ ﺍﺭﻓﺎﻕ ﻤﺸﻐل ﺍﻟﻁﺎﺒﻌﺔ ﻤﻊ ﺍﻟﺒﺭﻨﺎﻤﺞ، ﻭﺍﺫﺍ ﺍﺭﺩﺕ ﻤﻥ ﺒﺭﻨﺎﻤﺠﻙ ﺃﻥ ﻴﻌـﺯﻑ ﻤﻠـﻑ ﺼـﻭﺘﻲ،‬

‫ﻋﻠﻴﻙ ﺍﺭﻓﺎﻕ ﻤﺸﻐل ﺍﻟﺼﻭﺕ.‬

‫ﻗﺩ ﺘﺒﺩﻭ ﻓﻜﺭﺓ ﺍﺭﻓﺎﻕ ﻤﻠﻔﺎﺕ ﺍﻟﻤﺸﻐﻼﺕ ﻤﻘﺒﻭﻟﺔ -ﺍﻟﻰ ﺤﺩ ﻤﺎ - ﻟـﺒﻌﺽ ﺍﻟﻤﺒـﺭﻤﺠﻴﻥ، ﺍﻻ ﺍﻥ ﺍﻟﻤﺸـﻜﻠﺔ‬

‫ﺍﻟﺤﻘﻴﻘﺔ ﺍﻟﺘﻲ ﻜﻨﺎ ﻨﻭﺍﺠﻬﻬﺎ ﻫﻲ ﺍﻥ ﻟﻜل ﻁﺎﺒﻌﺔ ﻤﺸﻐل ﺨﺎﺹ ﺒﻬﺎ. ﻭﺒﻤﺎ ﺃﻨﻪ ﻟﻴﺱ ﻟﺩﻴﻨﺎ ﺍﻱ ﻓﻜـﺭﺓ ﻋـﻥ ﻨﻭﻋﻴـﺔ‬

‫ﺍﻟﻁﺎﺒﻌﺔ ﺍﻟﺘﻲ ﺴﺘﻜﻭﻥ ﻋﻠﻰ ﻁﺎﻭﻟﺔ ﺍﻟﻤﺴﺘﺨﺩﻡ، ﻓﺈﻥ ﺫﻟﻙ ﻴﻔـﺭﺽ ﻋﻠﻴﻨـﺎ ﺍﺭﻓـﺎﻕ ﻤﺸـﻐﻼﺕ ﻟﺠﻤﻴـﻊ ﺍﻨـﻭﺍﻉ‬
‫ﺍﻟﻁﺎﺒﻌﺎﺕ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﺴﻭﻕ. ﻓﻠﻭ ﺘﺫﻜﺭ ﺒﺭﻨﺎﻤﺞ 321 ‪ Lotus‬ﺍﻟـﺫﻱ ﻴﻌﻤـل ﺘﺤـﺕ ﻨﻅـﺎﻡ ‪،MS-DOS‬‬
‫ﺴﺘﻌﻠﻡ ﺍﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻴﺭﻓﻕ ﻤﻌﻪ ﺍﻜﺜﺭ ﻤﻥ 002 ﻤﻠﻑ، ﻫﺫﻩ ﺍﻟﻤﻠﻔـﺎﺕ ﻤـﺎﻫﻲ ﺍﻻ ﻤﺸـﻐﻼﺕ ﻟﻤﺨﺘﻠـﻑ ﺍﻨـﻭﺍﻉ‬
‫ﺍﻟﻁﺎﺒﻌﺎﺕ! ﺒﺎﻟﻨﺴﺒﺔ ﻟﻲ، ﻜﻨﺕ ﺍﻓﻀل ﺍﺴﺘﺨﺩﺍﻡ ﻴﺩﻱ ﻟﻜﺘﺎﺒﺔ ﺍﻟﻨﺘﺎﺌﺞ ﻋﻠﻰ ﺍﻟﻭﺭﻕ ﺒﺩﻻ ﻤـﻥ ﺘﺤﻤـل ﺘﻜـﺎﻟﻴﻑ ﻨﺴـﺦ‬
‫ﺍﻻﻗﺭﺍﺹ )ﻜﺎﻨﺕ ﻏﺎﻟﻴﺔ ﺠﺩﺍ ﻓﻲ ﺫﻟﻙ ﺍﻟﻭﻗﺕ( ﻟﻭﻀﻊ ﻤﺸﻐﻼﺕ ﺍﻟﻁﺎﺒﻌﺎﺕ ﻋﻠﻴﻬﺎ.‬

‫اﻻﻧﺘﻘﺎل اﻟﻰ ‪Windows‬‬
‫ﺍﻤﺎ ﻤﻊ ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ‪ Windows‬ﻓﻘﺩ ﺤﻠﺕ ﺍﻟﻤﺸﻜﻠﺔ ﺍﻟﺴﺎﺒﻘﺔ، ﺒﺤﻴﺙ ﻴﺘﻜﻔل ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ﺒﻤﻬﻤـﺔ ﺍﻟﺘﻌـﺭﻑ‬

‫ﻋﻠﻰ ﻋﺘﺎﺩ ﺍﻟﻜﻤﺒﻴﻭﺘﺭ ﻭﺍﺭﻓﺎﻕ ﻤﺸﻐﻼﺘﻬﺎ، ﻓﻬﻭ ﻴﻭﻓﺭ ﻟﻙ ﺍﻤﻜﺎﻨﻴﺔ ﺍﻟﻁﺒﺎﻋﺔ ﻓﻲ ﺒﺭﻨﺎﻤﺠﻙ ﺩﻭﻥ ﺍﻟﺤﺎﺠـﺔ ﻟﻤﻌﺭﻓـﺔ‬
‫ﻨﻭﻋﻴﺔ ﺍﻟﻁﺎﺒﻌﺔ، ﻭﻴﻤﻜﻨﻙ ﻤﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺼﻭﺭ ﻭﺍﻟﺭﺴﻭﻡ ﺍﻭ ﻋﺯﻑ ﻤﻠﻔﺎﺕ ﺍﻟﺼـﻭﺕ ﺍﻭ ﺍﺴـﺘﺨﺩﺍﻡ ﺍﻟﻔـﺄﺭﺓ ﻓـﻲ‬
‫ﺒﺭﻨﺎﻤﺠﻙ ﺩﻭﻥ ﺍﻻﻟﺘﺯﺍﻡ ﺒﺎﺭﻓﺎﻕ ﻤﺸﻐﻼﺕ ﺍﻻﺠﻬﺯﺓ، ﺍﻱ ﻜل ﻤﺎﻫﻭ ﻤﻁﻠﻭﺏ ﻤﻨﻙ -ﻜﻤﺒـﺭﻤﺞ - ﺍﻟﺘﺭﻜﻴـﺯ ﻋﻠـﻰ‬

‫ﺒﺭﻨﺎﻤﺠﻙ ﻭﺼﺭﻑ ﺍﻟﻨﻅﺭ ﻋﻥ ﺍﻻﻤﻭﺭ ﺍﻟﺘﻘﻨﻴﺔ ﺍﻟـﺩﻨﻴﺎ ﻜـﺎﻻﺠﻬﺯﺓ ﻭﺍﻟﻌﺘـﺎﺩ، ﺍﺩﺍﺭﺓ ﺍﻟـﺫﺍﻜﺭﺓ، ﺍﺩﺍﺭﺓ ﺍﻻﻗـﺭﺍﺹ‬
‫ﻭﻏﻴﺭﻫﺎ، ﻭﺍﻟﺘﻲ ﻴﺘﻜﻔل ﺒﻬﺎ ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ﺒﻜل ﺍﻗﺘﺩﺍﺭ.‬

‫ﺍﻻ ﺍﻥ ﺍﻟﺒﺭﻤﺠﺔ ﺘﺤﺕ ﺒﻴﺌﺔ ‪ Windows‬ﺘﺨﺘﻠﻑ ﺍﺨﺘﻼﻓﺎ ﺠﺫﺭﻴﺎ ﻋـﻥ ﺍﻟﺒﺭﻤﺠـﺔ ﺘﺤـﺕ ﺒﻴﺌـﺔ ‪،DOS‬‬
‫ﹰ‬

‫ﻓﺒﺭﻨﺎﻤﺠﻙ ﻟﻡ ﻴﻌﺩ ﻴﺴﺘﺨﺩﻡ ﺍﻟﻁﺭﻕ ﺍﻟﺘﻘﻠﻴﺩﻴﺔ ﻟﻘﻨﺹ ﺍﻟﻤـﺩﺨﻼﺕ ﻭﻋـﺭﺽ ﺍﻟﻤﺨﺭﺠـﺎﺕ، ﻓﻘـﻨﺹ ﺍﻟﻤـﺩﺨﻼﺕ‬

‫ﺍﺼﺒﺤﺕ ﺘﺘﻡ ﻤﻥ ﻗﺒل ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل، ﻭﺍﻟﺫﻱ ﻴﻘﻭﻡ ﺒﺎﺭﺴﺎﻟﻬﺎ ﻟـﻙ ﻋﻠـﻰ ﺸـﻜل ﺭﺴـﺎﺌل ‪ Messages‬ﻜـﺎﻟﻨﻘﺭ‬
‫‪ ،Click‬ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ‪... KeyDown‬ﺍﻟﺦ. ﻟﺫﻟﻙ، ﺍﻨﻘﻠﺒﺕ ﺍﻟﻤـﻭﺍﺯﻴﻥ ﺍﻟﺒﺭﻤﺠﻴـﺔ ﻓـﻲ ﺤﻴـﺎﺓ ﻤﻌﻅـﻡ‬

‫ﺍﻟﻤﺒﺭﻤﺠﻴﻥ، ﻟﺘﺼﺒﺢ ﺒﺭﺍﻤﺠﻬﻡ ﺘﺤﺘﻭﻱ ﻋﻠﻰ ﻋﺸﺭﺍﺕ -ﺒل ﻤﺌﺎﺕ - ﺍﻟﺤﻠﻘﺎﺕ ﺍﻟﺘﻜﺭﺍﺭﻴﺔ ﻟﻘﻨﺹ ﻫﺫﻩ ﺍﻟﺭﺴﺎﺌل.‬

‫ﺍﻤﺎ ﻤﻥ ﻨﺎﺤﻴﺔ ﻋﺭﺽ ﺍﻟﻤﺨﺭﺠﺎﺕ، ﻓﻠﻡ ﻴﻌﺩ ﻫﻨﺎﻙ ﺸـﺊ ﺍﺴـﻤﻪ ‪ Print‬ﻻﻅﻬـﺎﺭ ﺍﻟﻤﺨﺭﺠـﺎﺕ ﻋﻠـﻰ‬
‫ﺍﻟﺸﺎﺸﺔ، ﺤﻴﺙ ﻴﺘﻁﻠﺏ ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ‪ Windows‬ﻤﻥ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺍﻨﺸـﺎﺀ ﻨﻭﺍﻓـﺫ ﻭﺴـﻴﺎﻗﺎﺕ ﺭﺴـﻡ ﻭﺘﺴـﺠﻴل‬
‫ﻁﺒﻘﺎﺕ ﻟﻴﺘﻤﻜﻨﻭﺍ ﻤﻥ ﻋﺭﺽ ﺍﻟﻤﺨﺭﺠﺎﺕ ﻤﻥ ﺨﻼﻟﻬﺎ. ﻓﻠﻭ ﺍﺭﺍﺩ ﻤﺒﺭﻤﺞ ﺘﻌﻠﻡ ﻟﻐﺔ ﺒﺭﻤﺠـﺔ ﺠﺩﻴـﺩﺓ ﻟﻜﺘﺎﺒـﺔ ﺍﻭل‬

‫ﺒﺭﻨﺎﻤﺞ ﺸﻬﻴﺭ ‪ Hello World‬ﺘﺤﺕ ﺒﻴﺌﺔ ‪ ،Windows‬ﻋﻠﻴﻪ ﻜﺘﺎﺒﺔ ﻋﺸﺭﺍﺕ ﺍﻟﺴﻁﻭﺭ ﺍﻟﻤﻌﻘﺩﺓ ﺠـﺩﺍ ﻟﻌﻤـل‬
‫ﺫﻟﻙ، ﺍﻻﻤﺭ ﺍﻟﺫﻱ ﺍﺩﻯ ﺘﻘﺎﻋﺩ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﻤﻥ ﻋﺎﻟﻡ ﺍﻟﻤﺒﺭﻤﺠﺔ ﻭﻓﻀﻠﻭﺍ ﺍﻟﻌﻤل ﻋﻨﺩ ﺸـﺭﻜﺎﺕ ﺴـﻴﺎﺭﺍﺕ ﺍﻻﺠـﺭﺓ‬
V isual Basic .NET ‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮف ﻋﻠﻰ‬
5
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ ﻭﺍﻟﺘﻲ ﺘﻤﺜـل ﺒﺭﻨـﺎﻤﺞ ﻴﻘـﻭﻡ‬C ‫)ﺍﻟﺘﺎﻜﺴﻲ(!. ﻭﺤﺘﻰ ﺍﺭﻴﻙ ﺍﻻﻤﺭ ﺍﻟﻭﺍﻗﻊ، ﺍﻨﻅﺭ ﺇﻟﻰ ﻫﺫﻩ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﻤﻌﺩﺓ ﺒﻠﻐﺔ‬
:‫ﺒﻌﺭﺽ ﻨﺎﻓﺫﺓ ﺨﺎﻟﻴﺔ ﻓﻘﻁ‬
#include <windows.h>
LRESULT CALLBACK MainWndProc( HWND, UINT, WPARAM, LPARAM );
HINSTANCE ghInstance;
int PASCAL WinMain( HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpszCmdLine,
int nCmdShow )
}
WNDCLASS wc;
MSG msg;
HWND hWnd;
if( !hPrevInstance )
{
wc.lpszClassName = "ShowWindow";
wc.lpfnWndProc = MainWndProc;
wc.style = CS_OWNDC | CS_VREDRAW | CS_HREDRAW;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon( NULL, IDI_APPLICATION );
wc.hCursor = LoadCursor( NULL, IDC_ARROW );
wc.hbrBackground = (HBRUSH)( COLOR_WINDOW+1 );
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
}

RegisterClass( &wc );

ghInstance = hInstance;
hWnd = CreateWindow ( "ShowWindow",
"ShowWindow",
WS_OVERLAPPEDWINDOW|WS_HSCROLL|WS_VSCROLL,
0,
0,
600,
300,
NULL,
NULL,
hInstance,
NULL);

ShowWindow( hWnd, nCmdShow );
while( GetMessage( &msg, NULL, 0, 0 )) {
TranslateMessage( &msg );
DispatchMessage( &msg );
}
}

return (int) msg.wParam;
‫6‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬
‫,‪LRESULT CALLBACK MainWndProc( HWND hWnd, UINT msg, WPARAM wParam‬‬
‫) ‪LPARAM lParam‬‬
‫{‬
‫;‪PAINTSTRUCT ps‬‬
‫;‪HDC hDC‬‬
‫{ ) ‪switch( msg‬‬
‫:‪case WM_DESTROY‬‬
‫;) 0 (‪PostQuitMessage‬‬
‫;‪Break‬‬
‫:‪default‬‬
‫;)) ‪return( DefWindowProc( hWnd, msg, wParam, lParam‬‬
‫}‬
‫;0 ‪return‬‬

‫}‬

‫ﻭﻟﻭ ﺍﻨﻬﻡ ﺼﺒﺭﻭﺍ ﻟﻜﺎﻥ ﺨﻴﺭﺍ ﻟﻬﻡ، ﻓﺒﻌﺩ ﻓﺘﺭﺓ ﻟﻴﺴﺕ ﻁﻭﻴﻠﺔ ﻅﻬـﺭﺕ ﺤﻠـﻭل ﻤـﻥ ﻜﺒﺭﻴـﺎﺕ ﺸـﺭﻜﺎﺕ‬
‫ﺼﻨﺎﻋﺔ ﺍﻟﺒﺭﻤﺠﻴﺎﺕ ﻟﺘﻬﺴﻴل ﻋﻤﻠﻴﺔ ﺍﻟﺒﺭﻤﺠﺔ ﺘﺤﺕ ﻨﻅـﻡ ‪ ،Windows‬ﻭﺫﻟـﻙ ﺒـﺎﺨﺘﺭﺍﻉ ﺍﻟﻜﻠﻤـﺔ ﺍﻟﺴـﺤﺭﻴﺔ‬
‫‪ ،Visual‬ﻓﻜل ﻤﺎ ﻫﻭ ﻤﻁﻠﻭﺏ ﻤﻥ ﺍﻟﻤﺒﺭﻤﺞ ﺘﺼﻤﻴﻡ ﺸﺎﺸﺎﺕ )ﻨﻭﺍﻓﺫ( ﺒﺭﻨﺎﻤﺠﻪ ﺒﺎﻟﻔﺄﺭﺓ، ﻭﻜﺘﺎﺒﺔ ﺒﻀﻌﺔ ﺍﻭﺍﻤـﺭ‬

‫ﻴﺘﻡ ﺘﻨﻔﻴﺫﻫﺎ ﺒﻤﺠﺭﺩ ﻗﻴﺎﻡ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺒﺎﻟﺘﻔﺎﻋل ﻤﻊ ﺒﺭﻨﺎﻤﺠﻪ ﺴـﻭﺍﺀ ﺒﺎﻟﻔـﺄﺭﺓ ﺍﻭ ﻟﻭﺤـﺔ ﺍﻟﻤﻔـﺎﺘﻴﺢ ﺍﻭ ﺍﻨﻔـﻪ )ﻟﻘـﺩ‬
‫ﺸﺎﻫﺩﺕ ﻓﻌﻼ ﺍﺤﺩ ﺍﻟﺯﻤﻼﺀ ﻴﺴﺘﺨﺩﻡ ﺍﻨﻔﻪ ﻋﻠﻰ ﺍﻟﺸﺎﺸﺔ!(.‬

‫ﺒﻌﺩ ﺫﻟﻙ، ﻻﺤﻅ ﺍﻟﻤﺒﺭﻤﺠﻭﻥ ﺍﻥ ﻨﺴﺒﺔ ﻜﺒﻴﺭﺓ ﻤﻥ ﺸﻴﻔﺭﺍﺕ ﺒﺭﺍﻤﺠﻬﻡ ﻤﻜﺭﺭﺓ ﻭﻗﺩ ﻜﺘﺒﺕ ﻓـﻲ ﻋﺸـﺭﺍﺕ‬

‫ﺍﻟﻤﺸﺎﺭﻴﻊ، ﻓﻠﻭ ﺍﻤﻌﻨﺕ ﺍﻟﻨﻅﺭ ﻗﻠﻴ ﹰ، ﻟﻭﺠﺩﺕ ﺍﻥ ﻤﻌﻅﻡ ﺘﻁﺒﻴﻘﺎﺕ ‪ Windows‬ﺘﺘﺸﺎﺭﻙ ﺍﻟﻰ ﺤـﺩ ﻜﺒﻴـﺭ ﻓـﻲ‬
‫ﻼ‬
‫ﻤﻌﻅﻡ ﻭﻅﺎﺌﻔﻬﺎ ﺍﻟﺸﺎﺌﻌﺔ، ﻟﺫﻟﻙ ﻜﺎﻥ ﻋﻠﻰ ﻤﻁﻭﺭﻱ ﻨﻅﺎﻡ ‪ Windows‬ﺍﻴﺠﺎﺩ ﺤﻠﻭل ﻟﺘﺒﺎﺩل ﺍﻟﺒﻴﺎﻨـﺎﺕ ﻭﻤﺸـﺎﺭﻜﺔ‬

‫ﺍﻟﺸﻴﻔﺭﺍﺕ ﺒﻴﻥ ﺍﻟﺒﺭﺍﻤﺞ، ﺍﻻ ﺍﻥ ﺘﺤﻘﻴﻕ ﻫﺫﺍ ﺍﻟﻬـﺩﻑ ﺒـﺩﺍ ﻤﺴـﺘﺤﻴﻼ ﻟـﺒﻌﺽ ﺍﻟﻭﻗـﺕ، ﻻﻥ ﺠﻤﻴـﻊ ﺒـﺭﺍﻤﺞ‬
‫ﹰ‬
‫‪ Windows‬ﺘﻌﻤل ﻓﻲ ﻤﻨﺎﻁﻕ ﻤﺨﺘﻠﻔﺔ ﻭﻤﺴﺘﻘﻠﺔ ﺒﻬﺎ ﻓﻲ ﺍﻟـﺫﺍﻜﺭﺓ ﺘﺴـﻤﻰ ﻤﺴـﺎﺤﺎﺕ ﺍﻟﻌﻨﻭﻨـﺔ‬

‫‪Address‬‬

‫‪ ،Spaces‬ﻟﺫﻟﻙ ﺃﺴﺱ ﻤﻁﻭﺭﻭﺍ ‪ Windows‬ﺍﺴﻠﻭﺒﺎ ﺍﻭ ﺒﺭﻭﺘﻭﻜﻭل ﺒﺭﻤﺠـﻲ ﻴﺴـﻤﺢ ﻟﻠﺘﻁﺒﻴﻘـﺎﺕ ﺒﺎﻟﺘﺨﺎﻁـﺏ‬
‫ﻓﻴﻤﺎ ﺒﻴﻨﻬﺎ ﺒﻤﻌـﺎﻴﻴﺭ ﻭﻤﻭﺍﺼـﻔﺎﺕ ﻗﻴﺎﺴـﻴﺔ ﺘﺴـﻤﻰ ﺍﻟﺘﺒـﺎﺩل ﺍﻟـﺩﻴﻨﺎﻤﻴﻜﻲ ﻟﻠﺒﻴﺎﻨـﺎﺕ ‪Dynamic Data‬‬

‫‪.(DDE ) - Exchange‬‬

‫ﺍﻻ ﺍﻥ ‪ DDE‬ﻜﺎﻨﺕ ﺒﻬﺎ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﻌﻴﻭﺏ ﺍﻟﺘﻲ ﺤﺩﺕ ﺒﺎﻟﻤﺒﺭﻤﺠﻴﻥ ﺇﻟﻰ ﺘﺠﻨـﺏ ﺍﺴـﺘﺨﺩﺍﻤﻬﺎ، ﻜﻜﺜـﺭﺓ‬
‫ﺍﻻﻨﻬﻴﺎﺭﺍﺕ ﺍﻟﺘﻲ ﺘﺤﺩﺙ ﻓﻲ ﺍﻟﺒﺭﺍﻤﺞ، ﻭﺍﻻﺘﺼﺎﻻﺕ ﺩﺍﺌﻤﺔ ﺍﻻﻨﻘﻁﺎﻉ ﺒﻴﻥ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ، ﺒﺎﻻﻀـﺎﻓﺔ ﺍﻟـﻰ ﺼـﻌﻭﺒﺔ‬

‫ﻭﺘﻌﻘﻴﺩﺍﺕ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﻤﺼﺩﺭﻴﺔ ﻭﻏﻴﺭﻫﺎ، ﺇﻟﻰ ﺍﻥ ﻗﺎﻤﺕ ‪ Microsoft‬ﺒﺎﺼﺩﺍﺭ ﺘﻘﻨﻴﺔ ﺭﺒﻁ ﺍﻟﻜﺎﺌﻨﺎﺕ ﻭﺘﻀـﻤﻴﻨﻬﺎ‬

‫‪ (OLE ) - Object Linking & Embedding‬ﻭﺍﻟﺘﻲ ﺘﻌﺘﻤﺩ ﻓﻲ ﺒﻨﻴﺘﻬﺎ ﺍﻟﺘﺤﺘﻴﺔ ﻋﻠﻰ ‪ ،DDE‬ﺤﻴـﺙ‬

‫ﻭﻓﺭﺕ ﻗﺎﺒﻠﻴﺔ ﻟﺘﺒﺎﺩل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﻴﻥ ﺍﻟﺒﺭﺍﻤﺞ ﻭﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﺍﻟﻤﺨﺘﻠﻔﺔ ﻟﺘﻤﻜﻨﻙ ﻤﻥ ﺍﺩﺭﺍﺝ ﺠـﺩﻭل ﻤـﻥ‬

‫‪Microsoft‬‬

‫‪ Excel‬ﻟﺘﻀﻤﻴﻨﻪ ﺍﻭ ﺭﺒﻁﻪ ﻓﻲ ﻤﺴﺘﻨﺩ ‪.Microsoft Word‬‬
‫ﻓﻲ ﺍﻭﺍﺨﺭ ﻋﺎﻡ 3991 ﻏﻴﺭﺕ ‪ Microsoft‬ﺍﻟﺒﻨﻴﺔ ﺍﻟﺘﺤﺘﻴﺔ ﻟـ ‪ OLE‬ﺤﻴـﺙ ﻟـﻡ ﺘﻌـﺩ ﺘﻌﺘﻤـﺩ ﻋﻠـﻰ‬

‫‪ DDE‬ﻭﺘﻡ ﺍﻋﺎﺩﺓ ﺒﻨﺎﺌﻬﺎ ﻤﻥ ﺠﺩﻴﺩ ﻟﺘﺼﺩﺭ ﻤﺎ ﺴﻤﻲ 2‪ ،OLE‬ﻭﺍﻟﺘﻲ ﻤﻜﻨﺕ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﻤـﻥ ﺘﻁﺒﻴـﻕ ﺍﺴـﻠﻭﺏ‬
‫ﺍﻟﻌﻤل ﻓﻲ ﻨﻔﺱ ﺍﻟﻤﻜﺎﻥ ‪ In-place Activation‬ﺒﺤﻴﺙ ﻴﻤﻜﻨﻙ ﺘﺤﺭﻴﺭ ﺠﺩﻭل ‪ Excel‬ﻭﺍﻨﺕ ﻓـﻲ ﺩﺍﺨـل‬
‫ﻤﺴﺘﻨﺩ ‪ Word‬ﻓﻲ ﻨﻔﺱ ﺍﻟﻨﺎﻓﺫﺓ ﻭﺩﻭﻥ ﺍﻟﺤﺎﺠﺔ ﻟﻤﻐﺎﺩﺭﺓ ‪.Word‬‬
‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮف ﻋﻠﻰ ‪V isual Basic .NET‬‬
‫7‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫اﻟﺤﻠﻢ اﺻﺒﺢ ﺣﻘﻴﻘﺔ ﻣﻊ ‪COM‬‬
‫ﻤﻥ ﺍﻻﻨﺠﺎﺯﺍﺕ ﺍﻟﺘﻲ ﺍﺤﺩﺜﺕ ﺜﻭﺭﺓ ﻜﺒﻴﺭﺓ ﻓﻲ ﻋـﺎﻟﻡ ﺘﻁـﻭﻴﺭ ﺍﻟﺒـﺭﺍﻤﺞ ﺘﺤـﺕ ‪ ،Windows‬ﺘﻘﻨﻴـﺔ ﺒﺭﻤﺠـﺔ‬
‫ﺍﻟﻤﻜﻭﻨﺎﺕ ‪ ،(COM) - Component Object Model‬ﺤﻴﺙ ﻤﻜﻨﺕ ﻫﺫﻩ ﺍﻟﺘﻘﻨﻴﺔ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ –ﺒﻠﻐـﺎﺕ‬
‫ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﺨﺘﻠﻔﺔ - ﻤﻥ ﺍﻟﻤﺸﺎﺭﻜﺔ ﻓﻲ ﺘﻁﺒﻴﻘﺎﺘﻬﻡ ﺒﺎﺴﻠﻭﺏ ﻜﺎﺌﻨﻲ ﺍﻟﺘﻭﺠﻪ ‪ .Object Oriented‬ﻟـﻴﺱ ﻫـﺫﺍ‬
‫ﻓﻘﻁ، ﺒل ﺘﻌﺩﻯ ﺍﻻﻤﺭ ﺫﻟﻙ ﻟﻴﺼل ﺍﻟـﻰ ﺍﻟﻤﻜﻭﻨـﺎﺕ ﺍﻟﻤﻭﺯﻋـﺔ ‪،(DCOM) - Distributed COM‬‬

‫ﻟﺘﺼﺒﺢ ﻤﻜﻭﻨﺎﺕ ﺍﻟﺒﺭﺍﻤﺞ ﻤﻭﺯﻋﺔ ﻋﻠﻰ ﺍﺠﻬﺯﺓ ﻤﺨﺘﻠﻔﺔ، ﻭﻴﺘﻡ ﺘﺒﺎﺩل ﺍﻟﺒﻴﺎﻨـﺎﺕ ﻋـﻥ ﻁﺭﻴـﻕ ﺸـﺒﻜﺔ ﺍﻻﻨﺘﺭﻨـﺕ‬

‫ﺒﺸﻜل ﻤﺫﻫل، ﻓﻴﺴﺘﻁﻴﻊ ﺼﺩﻴﻘﻲ ﻓﻲ ﻤﻨﻐﻭﻟﻴﺎ ﻤﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺒﻌﺽ ﺍﺠﺯﺍﺀ ﺒﺭﻨـﺎﻤﺠﻲ ﺍﻟﻤﻭﺠـﻭﺩ ﻓـﻲ ﺠﻬـﺎﺯﻱ‬
‫ﺍﻟﻤﺤﻤﻭل ﺍﻟﺫﻱ ﺍﺼﻁﺤﺒﻪ ﻤﻌﻲ ﻓﻲ ﺭﺤﻼﺘﻲ ﺍﻟﺒﺭﻴﺔ ﺒﺼﺤﺭﺍﺀ ﺍﻟﺭﺒﻊ ﺍﻟﺨﺎﻟﻲ.‬

‫ﺍﺜﺭﺕ ‪ COM‬ﺒﺸﻜل ﺍﻴﺠﺎﺒﻲ ﻜﺒﻴﺭ ﻓﻲ ﻋﺎﻟﻡ ﺘﻁﻭﻴﺭ ﺍﻟﺒـﺭﺍﻤﺞ ﺘﺤـﺕ ‪ ،Windows‬ﻟﺩﺭﺠـﺔ ﻅﻬـﻭﺭ‬

‫ﺸﺭﻜﺎﺕ ﻤﺘﺨﺼﺼﺔ ﻓﻘﻁ ﻓﻲ ﺘﻁﻭﻴﺭ ﻤﻜﻭﻨـﺎﺕ ‪) COM‬ﻜـﺄﺩﻭﺍ ﺍﻟـﺘﺤﻜﻡ ‪ ،ActiveX Controls‬ﻤﻜﺘﺒـﺎﺕ‬
‫ﻓﺌﺎﺕ ‪.... ActiveX DLL‬ﺍﻟﺦ(، ﻭﺍﺼﺒﺤﺕ ﻋﻤﻠﻴﺔ ﺒﻨﺎﺀ ﺍﻟﺒﺭﺍﻤﺞ ﺘﻌﺘﻤﺩ ﻋﻠـﻰ ﺍﻟﺒﺭﻤﺠـﺔ ﻤﻜﻭﻨﻴـﺔ ﺍﻟﺘﻭﺠـﻪ‬

‫‪ Component Oriented Programming‬ﺒﺸـﻜل ـﺭ، ﻭﻻ ﺘﻜـﺎﺩ ﺘﺠـﺩ ﺃﻱ ـﺎﻤﺞ ﺍﻵﻥ ﺇﻻ‬
‫ﺒﺭﻨـ‬
‫ﻜﺒﻴـ‬
‫ﻭﻴﺴﺘﺨﺩﻡ ﻤﻜﻭﻨﺎﺕ ‪.COM‬‬

‫ﻤﻊ ﺫﻟﻙ، ﻓﺈﻥ ﺍﺴﺘﻴﻌﺎﺏ ﺍﻟﺒﻨﻴﺔ ﺍﻟﺘﺤﺘﻴﺔ ﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﻜﻭﻨﺎﺕ ‪ COM‬ﻤﺴﺎﻟﺔ ﺼﻌﺒﺔ ﺠـﺩﺍ، ﻓﻬـﻲ ﺘﺘﻁﻠـﺏ‬

‫ﺍﻟﺘﻭﻏل ﻓﻲ ﺘﻔﺎﺼﻴل ﻤﻌﻘﺩﺓ ﻻﺴﺘﺨﺩﺍﻡ ﻤﺎ ﻴﺴـﻤﻰ ﺍﻟﻭﺍﺠﻬـﺎﺕ ‪ ،Interfaces‬ﻭﻜﺜـﺭﺓ ﺍﻻﺨﻁـﺎﺀ ﻭﺍﻟﺸـﻭﺍﺌﺏ‬
‫ﺍﻟﺒﺭﻤﺠﻴﺔ ﺍﺼﺒﺤﺕ ﺍﻤﺭﺍ ﻁﺒﻴﻌﻴﹰ، ﻭﻋﻨﺩ ﺍﻟﺤﺩﻴﺙ ﻋـﻥ ﻤﺼـﺎﺩﺭ ﺍﻟﻨﻅـﺎﻡ ‪ System Resources‬ﻓﺤـﺩﺙ ﻭﻻ‬
‫ﺎ‬
‫ﹰ‬

‫ﺤﺭﺝ، ﻓﻬﻲ ﺘﺴﺘﻬﻠﻙ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﻤﺴﺎﺤﺎﺕ ﺍﻟﻐﻴﺭ ﻤﺴﺘﺨﺩﻤﺔ ﻟﻌﺩﻡ ﺘﻔﺭﻴﻎ ﺍﺠﺯﺍﺀ ﺍﻟﺫﺍﻜﺭﺓ ﻤﻥ ﺍﻟﻜﺎﺌﻨـﺎﺕ ﺍﻟﻤﺸـﺄﺓ،‬
‫ﺍﻤﺎ ﺒﺴﺒﺏ ﺍﻻﻨﻬﻴﺎﺭﺍﺕ ﺍﻟﻤﻔﺎﺠﺌﺔ ﻟﻠﺒﺭﺍﻤﺞ، ﺍﻭ ﻨﺴﻴﺎﻥ ﺤﺫﻑ ﻤﺅﺸـﺭﺍﺕ ﺍﻟﻜﺎﺌﻨـﺎﺕ ﺍﻟﺘـﻲ ﺍﻨﺸـﺄﻫﺎ ﺃﻭ ﺍﺴـﺘﺨﺩﻤﻬﺎ‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ.‬
‫ﻤﻥ ﻨﺎﺤﻴﺔ ﺍﺨﺭﻯ، ﻓﺈﻥ ﻤﻜﻭﻨﺎﺕ ‪ COM‬ﺘﻌﺘﻤﺩ ﺍﻋﺘﻤـﺎﺩﺍ ﻜﻠﻴـﺎ ﻋﻠـﻰ ﻤﺴـﺠل ﺍﻟﻨﻅـﺎﻡ ‪Windows‬‬
‫ﹰ‬
‫ﹰ‬

‫‪ ،Registry‬ﻭﺍﻱ ﻤﺸﻜﻠﺔ ﺘﺤﺩﺙ ﻓﻲ ﻫﺫﺍ ﺍﻟﻤﺴﺠل ﺘﺅﺜﺭ ﻋﻠﻰ ﺒﺎﻗﻲ ﺍﻟﻤﻜﻭﻨـﺎﺕ ﺍﻟﻤﺜﺒﺘـﺔ ﻓـﻲ ﺍﻟﺠﻬـﺎﺯ، ﻭﻟـﻥ‬
‫ﺘﺴﺘﻁﻴﻊ ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﺍﻻ ﺒﺎﻋﺎﺩﺓ ﺘﺭﻜﻴﺏ ‪ Reinstall‬ﺍﻟﺒﺭﺍﻤﺞ ﺍﻟﺘﺎﺒﻌﺔ ﻟﻬﺎ. ﻭﻋﻤﻠﻴﺔ ﺘﺭﻜﻴﺏ ﺍﻟﺒـﺭﺍﻤﺞ ﺒﺤـﺩ ﺫﺍﺘﻬـﺎ‬

‫ﻤﻌﻘﺩﺓ ﺠﺩﺍ، ﺍﺫ ﺘﺘﻁﻠﺏ ﻤﻨﻙ ﻨﺴﺦ ﻤﻠﻔﺎﺕ ﺍﻟﻤﻜﻭﻨﺎﺕ ﻭﻤﻥ ﺜﻡ ﺘﺴﺠﻴﻠﻬﺎ ﻓﻲ ﺍﻟﻤﺴـﺠل ﻭﺍﻋـﺩﺍﺩﻫﺎ ﻭﺍﻟﺘﺤﻘـﻕ ﻤـﻥ‬

‫ﺍﻻﺼﺩﺍﺭﺍﺕ ﺍﻻﻗﺩﻡ ﻭﻤﻥ ﺜﻡ ﺘﻌﺭﻴﻔﻬﺎ ﻋﻠﻰ ﺍﻟﺸﺒﻜﺔ ﺍﻟﻤﺤﻠﻴﺔ )ﺍﻥ ﻜﺎﻨـﺕ ‪ ،(DCOM‬ﻭﺍﻱ ﺨﻁـﺄ ﻓـﻲ ﻋﻤﻠﻴـﺔ‬

‫ﺘﺜﺒﻴﺕ ﺍﻟﺒﺭﺍﻤﺞ، ﻴﺅﺩﻱ ﺍﻟﻰ ﺤﺩﻭﺙ ﻜﺎﺭﺜﺔ ﻓﻲ ﺠﻬﺎﺯ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻭﺍﻟﺘـﺄﺜﻴﺭ ﻋﻠـﻰ ﺒـﺎﻗﻲ ﺍﻟﺒـﺭﺍﻤﺞ ﺍﻟﻤﺜﺒﺘـﺔ ﻓـﻲ‬

‫ﺍﻟﺠﻬﺎﺯ، ﻟﻴﻜﻭﻥ ﺍﻟﺤل ﺍﻟﻭﺤﻴﺩ ﺍﻋﺎﺩﺓ ﺘﻬﻴﺌﺔ ‪ Format‬ﺍﻟﻘﺭﺹ ﺍﻟﺼﻠﺏ. ﻭﻋﻨﺩ ﺍﻟﺤـﺩﻴﺙ ﻋـﻥ ﺍﻟﺘﻭﺍﻓﻘﻴـﺔ، ﻓـﻼ‬
‫ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﺼﺩﺍﺭﻴﻥ ﻤﺨﺘﻠﻔﻴﻥ ﻟﻨﻔﺱ ﺍﻟﻤﻜﻭﻥ ﺒﺴﺒﺏ ﻤﺸـﻜﻠﺔ ﺘﺴـﻤﻰ ‪ Versioning‬ﻟـﻴﺱ ﻫـﺫﺍ ﻤﺠـﺎل‬
‫ﺘﻔﺼﻴﻠﻬﺎ.‬

‫ﺗﺤﺪﻳﺎت اﻻﻧﺘﺮﻧﺖ‬
‫ﻤﻊ ﻅﻬﻭﺭ ﺍﻻﻨﺘﺭﻨﺕ ﺍﺼﺒﺤﺕ ﻤﺴﺄﻟﺔ ﺘﻜﺎﻤل ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﻤﻊ ﻫﺫﻩ ﺍﻟﺸﺒﻜﺔ ﺍﻤﺭ ﻀﺭﻭﺭﻱ ﺍﻥ ﻟﻡ ﻴﻜـﻥ ﺍﻟﺯﺍﻤـﻲ،‬
‫ﻓﻌﻤﻠﻴﺎﺕ ﺘﺤﺩﻴﺙ ﺍﻟﺒﺭﺍﻤﺞ ﻭﺘﺒﺎﺩل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻴﻤﺎ ﺒﻴﻨﻬﺎ ﻴﻤﻜﻥ ﺍﻥ ﺘﺨﻔﺽ ﺘﻜﺎﻟﻴﻔﻬﺎ ﻋﻥ ﻁﺭﻴـﻕ ﺍﻻﻨﺘﺭﻨـﺕ، ﺍﻀـﻑ‬

‫ﺍﻟﻰ ﺫﻟﻙ ﻤﺩﻯ ﺍﻟﺴﻬﻭﻟﺔ ﺍﻟﺘﻲ ﺘﻤﻜﻥ ﻤﺴﺘﺨﺩﻤﻴﻥ ﺍﻟﻜﻤﺒﻴﻭﺘﺭ –ﺤﻭل ﺍﻟﻌـﺎﻟﻡ - ﻤـﻥ ﺍﻟﻭﺼـﻭل ﺍﻟـﻰ ﺍﻟﻤﻌﻠﻭﻤـﺎﺕ‬
‫8‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺒﺎﻟﺘﺼﻔﺢ ﻓﻲ ﺍﻟﻤﻭﺍﻗﻊ ﺍﻟﻤﺨﺘﻠﻔﺔ. ﻫﺫﻩ ﺍﻟﺸﺒﻜﺔ ﻟﻡ ﻴﺤﺼﺭ ﻤﺠﺎﻟﻬﺎ ﻓﻲ ﻋﺭﺽ ﺍﻟﻤﻭﺍﻗﻊ ﻓﻘﻁ، ﺒـل ﺘﻌـﺩﻯ ﺍﻻﻤـﺭ‬
‫ﺍﻜﺜﺭ ﻤﻥ ﺫﻟﻙ ﺍﻟﻰ ﺍﻥ ﻴﺼل ﻟﻤﺴﺘﻭﻯ ﺘﻁﻭﻴﺭ ﺘﻁﺒﻴﻘﺎﺕ ﻭﻴﺏ ﺒﺎﺴـﺘﺨﺩﺍﻡ ﺘﻘﻨﻴـﺎﺕ ﻤﻌﺎﻟﺠـﺔ ﺍﻟﺼـﻔﺤﺎﺕ ﻋﻠـﻰ‬
‫ﺍﺠﻬﺯﺓ ﺍﻟﺨﻭﺍﺩﻡ ﻜﺘﻘﻨﻴﺔ ‪.(ASP) - Active Server Pages‬‬

‫ﻤﻊ ﺫﻟﻙ، ﻓﺈﻥ ﺘﻁﻭﻴﺭ ﺍﻟﻨﻅﻡ ﺍﻟﻜﺒﻴﺭﺓ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪ ASP‬ﺍﻤﺭ ﻤﻌﻘﺩ ﺠﺩﺍ، ﻭﻴﺘﻁﻠـﺏ ﻋﺸـﺭﺍﺕ ﺍﻟﺘﻨﻘﻴﺤـﺎﺕ‬
‫ﻭﺍﻟﺘﻌﺩﻴﻼﺕ ﻟﻠﺼﻔﺤﺔ ﺍﻟﻭﺍﺤﺩﺓ، ﺨﺎﺼﺔ ﺍﻥ ﻋﻠﻤﺕ ﺍﻥ ﺒﺭﻤﺠﺔ ‪ ASP‬ﻟﻴﺴﺕ ﻜﺎﺌﻨﻴﺔ ﺘﻭﺠـﻪ ‪ ،OOP‬ﺤﻴـﺙ ﺍﻨﻬـﺎ‬
‫ﻜﺎﻨﺕ ﺘﻌﺘﻤﺩ ﻋﻠﻰ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﺼﻐﺭﺓ ‪ VBScript‬ﻟﻜﺘﺎﺒﺔ ﺸﻴﻔﺭﺍﺕ ﺍﻟﺼﻔﺤﺎﺕ.‬

‫ﺍﻻ ﺍﻥ ﺩﻋﻡ ﺼﻔﺤﺎﺕ ‪ ASP‬ﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﻜﻭﻨﺎﺕ ‪ COM‬ﺍﺩﻯ ﺍﻟـﻰ ﺘﻜﺎﻤـل ﺤﻘﻴﻘـﻲ ﻭﺘﺴـﻬﻴل ﺍﻜﺒـﺭ‬

‫ﻭﻤﺭﻭﻨﺔ ﺍﻜﺜﺭ ﻓﻲ ﺘﻁﻭﻴﺭ ﺍﻟﻨﻅﻡ –ﺨﺎﺼﺔ ﺍﻟﻜﺒﻴﺭﺓ، ﻟﻴـﺘﻤﻜﻥ ﺍﻟﻤﺴـﺘﺨﺩﻤﻭﻥ ﻤـﻥ ﺘﻁـﻭﻴﺭ ﺘﻁﺒﻴﻘـﺎﺕ ﻤﺘﻌـﺩﺩﺓ‬
‫ﺍﻟﻁﺒﻘﺎﺕ ‪ nTied Applications‬ﺤﻘﻴﻘﻴﺔ، ﺘﻌﺘﻤﺩ ﻋﻠـﻰ ﻜﺎﺌﻨـﺎﺕ ‪ ADO‬ﻜﺨﻠﻔﻴـﺔ ﺍﻟﻨﻅـﺎﻡ ﻻﺩﺍﺭﺓ ﻗﻭﺍﻋـﺩ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ، ﻭﻤﻜﻭﻨﺎﺕ ‪ COM‬ﻻﺩﺍﺀ ﻭﻅﺎﺌﻑ ﺍﻟﻨﻅـﺎﻡ ﻜﻁﺒﻘـﺔ ﻭﺴـﻁﻰ، ﻭﺼـﻔﺤﺎﺕ ‪ ASP‬ﻟﺘﻤﺜـل ﻭﺍﺠﻬـﺔ‬
‫ﺍﻟﻤﺴﺘﺨﺩﻤﻴﻥ.‬
‫ﺍﻨﺘﺸﺭﺕ ﻨﻅﻡ ‪ ASP‬ﺍﻨﺘﺸﺎﺭﺍ ﻜﺒﻴﺭﺍ ﺒﻴﻥ ﺍﻟﻤﻭﺍﻗﻊ ﺍﻟﻌﺎﻟﻤﻴﺔ، ﺍﻻ ﺍﻥ ﺍﻟﻤﺸﻜﻠﺔ ﺍﻟﺘﻲ ﻭﺍﺠﻬﺕ ﻤﻁﻭﺭﻱ ﻨﻅـﻡ‬

‫ﻭﻴﺏ ﺘﻅﻬﺭ ﻋﻨﺩ ﺘﺒﺎﺩل ﻭﺘﺸﺎﺭﻙ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﻴﻥ ﺍﻟﻤﻭﺍﻗﻊ ﺍﻟﻤﺨﺘﻠﻔﺔ، ﻓﻤﺜﻼ ﻟﻭ ﻜﻨـﺕ ﺘﺼـﻤﻡ ﻤﻭﻗـﻊ ﻟﺒﻴـﻊ ﺍﻟﻤـﺎﺩﺓ‬
‫ﺍﻟﺨﺎﻡ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻓﻲ ﺍﻨﺘﺎﺝ ﺍﻟﻔﻼﻓل )ﺍﻟﻁﻌﻤﻴﺔ( ﻭﺍﺭﺩﺕ ﻤﻥ ﻫﺫﺍ ﺍﻟﻨﻅﺎﻡ ﺍﻥ ﻴﺴـﺘﻘﺒل ﺍﻟﻁﻠﺒـﺎﺕ ﻤـﻥ ﻤﺨﺘﻠـﻑ‬

‫ﺍﻟﺩﻭل ﺍﻟﻌﺭﺒﻴﺔ، ﻭﻋﻠﻰ ﺍﻻﺭﺠﺢ ﺴﺘﺘﻡ ﻋﻤﻠﻴﺔ ﺍﻟﺸﺭﺍﺀ ﺒﺎﻟﻌﻤﻠﺔ ﺍﻟﻤﺤﻠﻴﺔ ﻟﻠﺩﻭﻟﺔ، ﺍﻀﻑ ﺍﻟﻰ ﺫﻟﻙ ﻤﺴـﺄﻟﺔ ﺍﻟﺘﺴـﻌﻴﺭ‬
‫ﺤﻴﺙ ﺍﻨﻬﺎ ﺘﻌﺘﻤﺩ ﺍﻋﺘﻤﺎﺩﺍ ﻜﻠﻴﺎ ﻋﻠﻰ ﺍﻟﻘﻭﺓ ﺍﻟﺸﺭﺍﺌﻴﺔ ﻟﻌﻤﻠﺔ ﺘﻠﻙ ﺍﻟﺩﻭﻟﺔ، ﻭﺴﻭﻕ ﺍﻟﻤﻁـﺎﻋﻡ ﺍﻟﻤﻨﺎﻓﺴـﺔ ﻓـﻲ ﺍﻨﺘـﺎﺝ‬
‫ﹰ ﹰ‬
‫ﺴﻨﺩﻭﻴﺘﺸﺎﺕ ﺍﻟﻔﻼﻓل، ﻟﺫﻟﻙ ﻗﺩ ﺘﺤﺘﺎﺝ ﺍﻟﻰ ﺘﺒﺎﺩل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻊ ﻤﻭﺍﻗﻊ ﺍﺨﺭﻯ ﺘﺤﺩﺩ ﻟـﻙ ﺍﻟﺴـﻌﺭ ﺍﻟﻤﻨﺎﺴـﺏ ﻓـﻲ‬

‫ﻭﻗﺕ ﻤﻌﻴﻥ، ﻭﻤﻭﺍﻗﻊ ﺍﺨﺭﻯ ﺘﻤﻜﻥ ﺍﻟﻤﺴﺘﺨﺩﻤﻴﻥ ﻤﻥ ﻤﺭﺍﻗﺒﺔ ﻋﻤﻠﻴﺎﺕ ﺸﺤﻥ ﺍﻟﻔﻼﻓل ﻭﺒﻴﺎﻥ ﻤﻭﺍﻗﻌﻬﺎ ﺍﻟﺤﺎﻟﻴﺔ.‬

‫ﺍﻥ ﺍﺭﺩﺕ ﺘﺒﺎﺩل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻊ ﻫﺫﻩ ﺍﻟﻤﻭﺍﻗﻊ ﺒﺸﻜل ﺘﻘﻠﻴﺩﻱ، ﻓﺎﻟﻌﻤﻠﻴﺔ ﺘـﺘﻡ ﺒﺎﺭﺴـﺎل ﺼـﻔﺤﺎﺕ ‪HTML‬‬

‫ﻤﻥ ﻤﻭﻗﻊ ﺍﻟﻰ ﺍﺨﺭ، ﻭﻋﻠﻴﻙ ﺍﻟﻘﻴﺎﻡ ﺒﺠﻤﻴﻊ ﺍﻟﺨﻁﻭﺍﺕ ﺍﻟﻼﺯﻤﺔ ﻟﺤﺫﻑ ﺍﻟﻭﺴﻭﻡ ‪) Tags‬ﺍﻟﺘـﻲ ﺘﺴـﺘﺨﺩﻡ ﻟﺘﻨﺴـﻴﻕ‬
‫ﺼﻔﺤﺎﺕ ‪ ،(HTML‬ﻭﻫﺫﻩ ﺒﺤﺩ ﺫﺍﺘﻬﺎ ﻋﻤﻠﻴﺔ ﻤﻌﻘﺩﺓ ﺠﺩﺍ، ﻭﺘﺘﻁﻠﺏ ﺠﻬﺩ ﻭﻭﻗﺕ ﺍﻀﺎﻓﻲ. ﻟﻴﺱ ﻫﺫﺍ ﻓﻘـﻁ، ﺒـل‬
‫ﺍﻥ ﺍﻱ ﺘﻌﺩﻴل ﺒﺴﻴﻁ ﻓﻲ ﺼﻔﺤﺎﺕ ﺍﺤﺩ ﺍﻟﻤﻭﺍﻗﻊ ﻗﺩ ﻴﺅﺩﻱ ﺍﻟﻰ ﻜﺎﺭﺜﺔ ﻓﻲ ﻋﻤﻠﻴﺔ ﻨﻘل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻋﺩﻡ ﺩﻗﺘﻬـﺎ ﻭﻗـﺩ‬

‫ﻴﺼل ﺍﻻﻤﺭ ﺍﻥ ﺘﻜﻭﻥ ﺍﻟﻁﻠﺒﻴﺔ ﻓﻼﻓل ﻭﻴﺘﻡ ﺸﺤﻥ ﺴﻨﺩﻭﻴﺘﺸﺎﺕ ﻜﺒﺩﺓ ﺒﻠﺩﻱ!‬
‫ﻟﺫﻟﻙ ﺍﻋﺘﻤﺩ ﺍﻟﻤﻁﻭﺭﻭﻥ ﻋﻠﻰ ﺘﻘﻨﻴﺔ ‪ (SOAP) – Simple Object Access Protocol‬ﺒﺤﻴـﺙ‬

‫ﻴﺘﻡ ﻨﻘل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻋﻥ ﻁﺭﻴﻕ ﻟﻐﺔ ‪) XML‬ﻭﻫﻲ ﻟﻐﺔ ﻭﺼﻑ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻟﻴﺱ ﺘﻨﺴﻴﻕ ﺍﻟﺒﻴﺎﻨـﺎﺕ ﻜــ ‪(HTML‬‬
‫ﻭﺍﺴﺘﺨﺩﺍﻡ ﺒﺭﻭﺘﻭﻜﻭﻻﺕ ﺍﻻﺘﺼﺎل ‪.TCP/IP‬‬

‫ﻗﺩ ﺘﻜﻭﻥ ﻓﻜﺭﺓ ‪ SOAP‬ﻤﻤﺘﻌﺔ ﺠﺩﺍ، ﻭﻟﻜﻥ -ﻤﻊ ﺍﻻﺴﻑ ﺍﻟﺸﺩﻴﺩ - ﺍﺴﺘﺨﺩﺍﻡ ﻫﺫﻩ ﺍﻟﺘﻘﻨﻴـﺔ ﻤﻌﻘـﺩ ﺠـﺩﺍ،‬

‫ﻭﻴﺘﻁﻠﺏ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﺨﺒﺭﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ، ﺒﺤﻴﺙ ﺍﻨﺤﺼﺭ ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﻋﻠﻰ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺍﻟﻤﺤﺘـﺭﻓﻴﻥ ﻓﻘـﻁ، ﻜـﺫﻟﻙ‬
‫ﻜﺜﺭﺓ ﺍﻻﺨﻁﺎﺀ ﻭﺍﻟﺸﻭﺍﺌﺏ ﺍﻟﺒﺭﻤﺠﻴﺔ ‪ Bugs‬ﻓﻲ ﺘﻁﻭﻴﺭ ﻨﻅﻡ ﺘﻌﺘﻤﺩ ﻋﻠﻰ ‪ SOAP‬ﺍﻤﺭ ﻻ ﻤﻔﺭ ﻤﻨﻪ.‬

‫ﻋﺸﺮات اﻟﺘﻘﻨﻴﺎت ﻻداء اﻟﻮﻇﺎﺋﻒ‬

‫ﻜﻤﺎ ﺭﺃﻴﺕ ﻓﻲ ﺍﻟﻔﻘﺭﺍﺕ ﺍﻟﺴﺎﺒﻘﺔ، ﻓﺈﻥ ﺘﻁﻭﻴﺭ ﺍﻟﺒﺭﺍﻤﺞ ﻤﺴﺄﻟﺔ ﻤﻌﻘﺩﺓ ﺠﺩﺍ ﻭﺘﺘﻁﻠﺏ ﺩﺭﺍﻴﺔ ﻜﺎﻓﻴﺔ ﻓﻲ ﺍﻟﺘﻌﺎﻤل ﻤـﻊ‬

‫ﺍﻟﺘﻘﻨﻴﺎﺕ ﺍﻟﻤﺨﺘﻠﻔﺔ، ﻓﻠﻜﻲ ﺘﻁﻭﺭ ﻤﻭﺍﻗﻊ ﻭﻴﺏ ﺩﻴﻨﺎﻤﻴﻜﻴﺔ ﻋﻠﻴﻙ ﺘﻌﻠﻡ ‪) VBScript‬ﺍﻥ ﻜﺎﻨﺕ ﻤﻥ ﺠﻬـﺔ ﺍﻟﻌﻤﻴـل(‬
‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮف ﻋﻠﻰ ‪V isual Basic .NET‬‬
‫9‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻭﺘﻌﻠﻡ ‪) ASP‬ﺍﻥ ﻜﺎﻨﺕ ﻤﻥ ﺠﻬﺔ ﺍﻟﺨﺎﺩﻡ(، ﻭﺍﻥ ﺍﺭﺩﺕ ﺒﻨﺎﺀ ﻨﻅﻡ ﻗﻭﺍﻋﺩ ﺒﻴﺎﻨﺎﺕ ﻋﻤﻼﻗـﺔ ﻋﻠﻴـﻙ ﺍﺘﻘـﺎﻥ ﻟﻐـﺎﺕ‬
‫ﺍﻻﺴﺘﻌﻼﻡ ‪ T-SQL‬ﻟﻠﺤﺼﻭل ﻋﻠﻰ ﺍﻜﺒﺭ ﻗﺩﺭ ﻤﻥ ﺘﺤﺴـﻴﻥ ﻟﻠﻜﻔـﺎﺀﺓ ‪ ،Optimization‬ﻭﺍﻥ ﺍﺭﺩﺕ ﺘﻁـﻭﻴﺭ‬
‫ﻤﻜﻭﻨﺎﺕ ‪ COM‬ﺒﻔﺎﻋﻠﻴﺔ ﺍﻜﺜﺭ ﻭﺩﻭﻥ ﺤﺩﻭﺩ ﻋﻠﻴﻙ ﺘﻌﻠﻡ ﺍﺤﺩ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﺘﻘﺩﻤـﺔ ﻜــ ++‪،Visual C‬‬

‫ﻭﺍﻥ ﺍﺭﺩﺕ ﻤﺨﺎﻁﺒﺔ ﺘﻁﺒﻴﻘﺎﺕ ‪ Microsoft Office‬ﺍﻟﺸﻬﻴﺭﺓ ﻓﻼ ﻤﺨﺭﺝ ﻟـﻙ ﺍﻻ ﺒﺎﺴـﺘﺨﺩﺍﻡ ‪ ،VBA‬ﺍﻤـﺎ ﺍﻥ‬
‫ﺍﺭﺩﺕ ﺘﻁﻭﻴﺭ ﺒﺭﺍﻤﺞ ﺘﻌﻤل ﺘﺤﺕ ﻨﻅﻡ ‪ Windows‬ﺒﺴﻬﻭﻟﺔ ﻭﻜﺴﺭ ﺤـﺎﺠﺯ ﺍﻟﻭﻗـﺕ ﻓﺴـﺘﺠﺩ ﻀـﺎﻟﺘﻙ ﻓـﻲ‬

‫‪.Visual Basic‬‬

‫ﻟﻴﺱ ﻫﺫﺍ ﻓﻘﻁ، ﺒل ﺤﺘﻰ ﺍﻟﻭﻅﺎﺌﻑ ﺍﻟﻤﺘﺸﺎﺒﻬﻪ ﺘﻨﺠﺯ ﺒﺘﻘﻨﻴﺎﺕ ﻤﺨﺘﻠﻔـﺔ، ﻓﻠـﺩﻴﻙ ﻤـﺜﻼ ﺍﻟﺘﻘﻨﻴـﺎﺕ ‪،ADO‬‬

‫‪ ،DAO‬ﻭ‪ RDO‬ﻟﺘﻁﻭﻴﺭ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﺍﻟﻤﻌﺘﻤﺩﺓ ﻋﻠﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ ،Databases‬ﻭﻫﻨـﺎﻙ ﺍﻴﻀـﺎ ﻤﺠﻤﻭﻋـﺔ‬
‫ﻤﻥ ﺍﻟﺘﻘﻨﻴﺎﺕ ﻜـ ‪ ،DirectX ،GDI‬ﻭ ‪ OpenGL‬ﻟﺘﻁﻭﻴﺭ ﺍﻟﻨﻅﻡ ﺍﻟﺘـﻲ ﺘﻌﺘﻤـﺩ ﻋﻠـﻰ ﺍﻟﺼـﻭﺭ ﻭﺍﻟﺭﺴـﻭﻡ‬

‫ﺒﻜﺜﺭﺓ.‬

‫ﻜﺎﻨﺕ ﻫﺫﻩ ﺠﻭﻟﺔ ﺴﺭﻴﻌﺔ ﺤﻭل ﺒﻨﺎﺀ ﺍﻟﺒﺭﺍﻤﺞ ﻓﻲ ﺍﻟﺴﻨﻭﺍﺕ ﺍﻟﺴﺎﺒﻘﺔ، ﺘﺫﻜﺭ ﺍﻥ ﻜﻼﻤـﻲ ﻤﻭﺠـﻪ ﻟﺘﻘﻨﻴـﺎﺕ‬
‫‪ Microsoft‬ﻓﻘﻁ. ﻭﺍﻥ ﻟﻡ ﺘﻜﻥ ﻟﺩﻴﻙ ﺍﻱ ﻤﻌﺭﻓﺔ ﺒﻤﺎ ﺴﺒﻕ ﺫﻜﺭﻩ ﻤﻥ ﺘﻘﻨﻴﺎﺕ ﺒﺭﻤﺠﻴﺔ، ﻓـﺄﺭﺠﻭ ﺍﻥ ﻻ ﻴﺼـﻴﺒﻙ‬

‫ﺫﻟﻙ ﺒﺎﻻﺤﺒﺎﻁ، ﺒل ﻋﻠﻰ ﺍﻟﻌﻜﺱ ﻤﻥ ﺫﻟﻙ، ﻴﻤﻜﻨﻙ ﺃﻥ ﺘﻌﺘﺒﺭ ﻨﻔﺴﻙ ﻤﺒﺭﻤﺞ ﻤﺤﻅﻭﻅ ﺠﺩﺍ، ﺤﻴـﺙ ﺴـﺘﺒﺩﺃ ﺤﻴﺎﺘـﻙ‬
‫ﺍﻟﺠﺩﻴﺩﺓ ﻤﻥ ﺤﻴﺙ ﺍﻨﺘﻬﻰ ﺍﻵﺨﺭﻴﻥ، ﻭﻤﻊ ﺍﺤﺩﺙ ﻭﺍﻓﻀل ﺘﻘﻨﻴﺔ ﺘﺴﺘﺨﺩﻡ ﻟﺘﻁﻭﻴﺭ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﻓـﻲ ﺍﻟﻘـﺭﻥ ﺍﻟﺤـﺎﺩﻱ‬

‫ﻭﺍﻟﻌﺸﺭﻴﻥ ﻭﻫﻲ ‪.Microsoft .NET‬‬

‫اﻟﺤﻴﺎة ﺑﻌﺪ ‪.NET‬‬
‫ﻻ ﺍﺩﻋﻲ ﻫﻨﺎ ﻋﻠﻡ ﺍﻟﻐﻴﺏ ﻭﻭﺼﻑ ﻤﺴﺘﻘﺒل ﺘﻁﻭﻴﺭ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ، ﻭﻟﻜﻥ ﻴﻤﻜﻨﻙ ﺍﻋﺘﺒﺎﺭ ﻤﺎ ﺴﺎﺫﻜﺭﻩ ﻓـﻲ ﺍﻟﻔﻘـﺭﺍﺕ‬
‫ﺍﻟﺘﺎﻟﻴﺔ ﻋﺭﺽ ﺴﺭﻴﻊ ﻻﺴﺘﺭﺍﺘﻴﺠﻴﺔ ‪ .NET‬ﻭﺒﻴﺎﻥ ﻤﺩﻯ ﺘﺎﺜﻴﺭﻫﺎ ﻋﻠﻰ ﺼﻨﺎﻋﺔ ﺍﻟﺒﺭﻤﺠﻴﺎﺕ.‬

‫اﻻﺳﺘﻘﻼﻟﻴﺔ ﻋﻦ ﻣﻨﺼﺎت اﻟﻌﻤﻞ‬

‫ﺍﻜﺘﺏ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻤﺭﺓ ﻭﺍﺤﺩﺓ ﻓﻘﻁ ﻭﺴﻴﺘﻡ ﺘﻨﻔﻴﺫﻩ ﻋﻠﻰ ﻤﺨﺘﻠﻑ ﻤﻨﺼﺎﺕ ﺍﻟﻌﻤل ﺍﻟﻤﺨﺘﻠﻔـﺔ: ﻜـﺎﻻﺠﻬﺯﺓ ﺍﻟﻤﺤﻤﻭﻟـﺔ‬
‫‪ ،Notebooks‬ﺨﺎﺩﻤـﺎﺕ ‪ ،Servers‬ﻫﻭﺍﺘـﻑ ﺠﻭﺍﻟـﺔ ‪ ،Mobiles‬ﺘﻠﻴﻔﺯﻴﻭﻨـﺎﺕ ﺭﻗﻤﻴـﺔ ‪،Digital TV‬‬

‫ﺜﻼﺠﺎﺕ، ﻁﺎﺌﺭﺍﺕ، ﺍﺒﻭﺍﺏ ﻜﺭﺍﺝ، ﺴﻴﺎﺭﺍﺕ، ﻭﻜل ﺸﺊ ﺭﻗﻤﻲ ‪ .Digital‬ﻭﺍﻥ ﻜﻨـﺕ ﺸـﺨﺹ ﺘﺴـﻜﻥ ﻓـﻲ‬
‫ﻤﻨﻁﻘﺔ ﺒﻌﻴﺩﺓ ﻋﻥ ﻋﺎﺌﻠﺘﻙ ﻭﻻ ﺘﺠﻴﺩ ﺍﻟﻁﺒﺦ، ﻓﻴﻤﻜﻨﻙ ﻁﻠﺏ ﺸـﻴﻔﺭﺓ ﻤﺼـﺩﺭﻴﺔ ﻤـﻥ ﺍﻟﻭﺍﻟـﺩﺓ ﻟﻜﺘﺎﺒـﺔ ﺒﺭﻨـﺎﻤﺞ‬

‫ﻟﺘﺤﻅﻴﺭ ﺍﻟﻜﺒﺴﺔ ﻭﻤﻥ ﺜﻡ ﺘﺭﻜﻴﺒﻪ ﻓﻲ ﺍﻟﻔﺭﻥ )ﺍﻟﺫﻱ ﺴﻴﻜﻭﻥ ﺭﻗﻤﻲ ﻻﺤﻘـﺎ( ﻻﻨﺠـﺎﺯ ﺍﻟﻜﺒﺴـﺔ. ﻭﻫـﺫﺍ ﺒﻔﻀـل‬

‫ﺍﺴﺘﻘﻼﻟﻴﺔ ﺒﺭﺍﻤﺠﻙ ﻋﻥ ﻤﻨﺼﺎﺕ ﺍﻟﻌﻤل ﺍﻟﺫﻱ ﺘﻘﺩﻤﻪ ‪.NET‬‬

‫ﺍﻻﺴﺘﻘﻼﻟﻴﺔ ﻋﻥ ﻤﻨﺼﺎﺕ ﺍﻟﻌﻤل ﻻ ﺘﻨﺤﺼﺭ ﺤﻭل ﺍﻟﻌﺘﺎﺩ ‪ Hardware‬ﻓﻘﻁ، ﺒل ﺘﺸـﻤل ﻨﻅـﻡ ﺍﻟﺘﺸـﻐﻴل‬
‫ﺍﻟﻤﺨﺘﻠﻔﺔ، ﻓﺤﺎﻟﻴﺎ ﺒﺭﺍﻤﺠﻙ ﻴﻤﻜﻨﻬﺎ ﺍﻥ ﺘﻌﻤل ﻋﻠﻰ ﻤﺨﺘﻠﻑ ﺍﺼﺩﺍﺭﺍﺕ ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ‪ ،Windows‬ﻭﻗﺭﻴﺒـﺎ ﻗـﺩ‬

‫ﻨﺭﻯ ﺍﻥ ﺍﻁﺎﺭ ﻋﻤل ‪ .NET Framework‬ﺴﻴﺩﻋﻡ ﻓﻲ ﺍﻨﻅﻤﺔ ﺍﻟﺘﺸـﻐﻴل ﺍﻻﺨـﺭﻯ ﻜــ ‪ Linux‬ﻭﺤﺘـﻰ‬
‫‪.Mac‬‬

‫ﺍﻟﻨﺘﻴﺠﺔ ﺍﻻﻴﺠﺎﺒﻴﺔ ﻤﻥ ﺍﺴﺘﻘﻼﻟﻴﺔ ﺒﺭﺍﻤﺠﻙ ﻋﻥ ﻤﻨﺼﺎﺕ ﺍﻟﻌﻤل ﺘﻘﺘﻀﻲ ﻤﻨﻙ –ﻜﻤﺒﺭﻤﺞ - ﺍﻟﺘﺭﻜﻴـﺯ ﻋﻠـﻰ‬

‫ﺒﺭﺍﻤﺠﻙ ﻓﻘﻁ ﺒﻐﺽ ﺍﻟﻨﻅﺭ ﻋﻥ ﺍﻟﻌﺎﻟﻡ ﺍﻟﺨﺎﺭﺠﻲ ﺍﻭ ﺍﻟﻤﻜﺎﻥ ﺍﻟﺫﻱ ﺴﻴﺘﻡ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻓﻴﻪ، ﻤﻊ ﺫﻟﻙ ﻗـﺩ ﺘﺴـﺎل‬
‫01‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺴﺅﺍل ﺒﺩﻴﻬﻲ ﻭﺘﻘﻭل: ﺍﻥ ﻜﺎﻨﺕ ﺒﺭﺍﻤﺞ ﻤﺴﺘﻘﻠﺔ ﻋﻥ ﻤﻨﺼﺎﺕ ﺍﻟﻌﻤل، ﻓﻜﻴﻑ ﺴـﻴﺘﻡ ﺘﻨﻔﻴـﺫ ﺍﻟﻭﻅـﺎﺌﻑ ﺍﻟﻤﺨﺘﻠﻔـﺔ‬
‫ﻭﺍﻟﺘﻲ ﻻ ﺘﺘﻭﻓﺭ ﻓﻲ ﻤﻨﺼﺔ ﻋﻤل ﻤﻌﻴﻨﺔ، ﻭﺍﻟﺠﻭﺍﺏ ﺒﻜل ﺒﺴﺎﻁﺔ ﻴﻌﺘﻤﺩ ﻋﻠﻰ ﻨﻭﻋﻴﺔ ﺍﻟﺒﺭﻨـﺎﻤﺞ ﺍﻟـﺫﻱ ﺘﺼـﻤﻤﻪ،‬
‫ﻓﺒﻜل ﺘﺄﻜﻴﺩ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﻤﺼﺩﺭﻴﺔ ﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﻭﺍﻟﺩﺓ )ﺘﺤﻀﻴﺭ ﺍﻟﻜﺒﺴﺔ( ﻟﻥ ﺘﻘـﻭﻡ ﺒﺘﺸـﻐﻴﻠﻪ ﻓـﻲ ﻏﺴـﺎﻟﺔ ﺍﻟﻤﻼﺒـﺱ‬

‫)ﺍﻟﺘﻲ ﺴﺘﻜﻭﻥ ﺭﻗﻤﻴﺔ ﺍﻴﻀﺎ(، ﻭﺍﻨﻤﺎ ﻤﻭﺠﻬﻪ ﺍﻟﻰ ﺍﻟﻔﺭﻥ ﺍﻟﺭﻗﻤﻲ. ﻟﺫﻟﻙ ﺍﺭﻴﺩ ﺘﻭﻀﻴﺢ ﺍﻥ ﺍﻟﻤﻘﺼـﺩ ﻤـﻥ ﻗﻀـﻴﺔ‬
‫ﺍﺴﺘﻘﻼﻟﻴﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻋﻥ ﻤﻨﺼﺎﺕ ﺍﻟﻌﻤل ﻤﻴﺯﺓ ﻤﻥ ﺍﻁﺎﺭ ﻋﻤـل ‪ .NET Framework‬ﻭﻟـﻴﺱ ﻟﻠﻤﺒـﺭﻤﺞ ﺍﻱ‬

‫ﻋﻼﻗﺔ ﻤﺒﺎﺸﺭﺓ ﺒﻬﺎ، ﻓﻜل ﻤﺎﻫﻭ ﻤﻁﻠﻭﺏ ﻤﻨﻪ ﻜﺘﺎﺒﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻓﻘﻁ ﺒﺤﻴﺙ ﻴﻼﺌﻡ ﺍﻟﺒﻴﺌﺔ ﺍﻟﺘﻲ ﺴﻴﻌﻤل ﺒﻬﺎ.‬

‫‪ .NET‬ﻧﺴﺨﺔ ﻣﺤﺴﻨﺔ ﻣﻦ ‪COM‬‬
‫ﻗﺩ ﹸﻔﺎﺠﺄ ﺍﻥ ﺍﺨﺒﺭﺘﻙ ﺍﻥ ﺍﻻﺴﻡ ﺍﻻﺒﺘﺩﺍﺌﻲ ﻟﻤﺸﺭﻭﻉ ‪ .NET‬ﻜﺎﻥ ﻴﺴﻤﻰ 0.2 ‪ ،COM‬ﺍﻱ ﺍﻟﺠﻴـل ﺍﻟﺘـﺎﻟﻲ ﻤـﻥ‬
‫ﺘ‬
‫ﺒﺭﻤﺠﺔ ﺍﻟﻤﻜﻭﻨﺎﺕ ‪ ،COM‬ﻭﻫﺫﻩ ﺒﺤﺩ ﺫﺍﺘﻬﺎ ﺤﻘﻴﻘﺔ ﺍﻥ ﺍﺨﺫﺘﻬﺎ ﺒﺸﻜل ﻨﻅﺭﻱ. ﻓﺎﻟﻔﻜﺭﺓ ﻤـﻥ ‪ COM‬ﻭ ‪.NET‬‬
‫ﺘﻘﺭﻴﺒﺎ ﻤﺘﻁﺎﺒﻘﺔ –ﻨﻅﺭﻴﺎ - ﻤﻥ ﻤﻨﻁﻠﻕ ﺘﻭﺯﻴﻊ ﺍﻟﺸﻴﻔﺭﺍﺕ ﻭﺍﻻﺴﺘﻘﺎﻟﻴﺔ ﺍﻟﺸﺒﻪ ﺘﺎﻤﺔ ﻋـﻥ ﻤﻨﺼـﺎﺕ ﺍﻟﻌﻤـل، ﺍﻻ ﺍﻥ‬
‫‪ .NET‬ﺘﺨﺘﻠﻑ ﺍﺨﺘﻼﻓﺎ ﺠﻭﻫﺭﻴﺎ ﻜﺒﻴﺭﺍ ﻓﻲ ﺒﻨﻴﺘﻬﺎ ﺍﻟﺘﺤﺘﻴﺔ ﻋﻥ ‪ ،COM‬ﺤﻴـﺙ ﺍﻥ ﺘﻘﻨﻴـﺔ ‪ .NET‬ﺘـﻡ ﺍﻋـﺎﺩﺓ‬
‫ﹰ‬
‫ﹰ‬
‫ﹰ‬

‫ﺒﻨﺎﺌﻬﺎ ﻤﻥ ﺠﺩﻴﺩ ﻭﻋﻭﻟﺠﺕ ﺍﻟﻌﺸﺭﺍﺕ ﻤﻥ ﺍﻟﻤﺸﺎﻜل ﺍﻟﺘﻲ ﻭﺍﺠﻬﺕ ﻤﺒﺭﻤﺠﻲ ‪ COM‬ﺴﺎﺒﻘﺎ.‬

‫ﺍﻭل ﻤﺸﻜﻠﺔ ﺍﺒﺘﺩﺍﺌﻴﺔ ﺘﻡ ﺤﻠﻬﺎ ﻫﻲ ﺍﻻﺴﺘﻐﻨﺎﺀ ﻋـﻥ ﻤﺴـﺠل ﺍﻟﻨﻅـﺎﻡ ‪ ،System Registry‬ﺤﻴـﺙ ﺍﻥ‬
‫ﻤﻜﻭﻨﺎﺕ ‪ .NET‬ﺘﺼل ﺍﻟﻴﻬﺎ ﻭﺘﺴﺘﻌﻠﻡ ﻋﻨﻬﺎ ﻤﺒﺎﺸﺭﺓ ﻋﻥ ﻁﺭﻴﻕ ﻤﻠﻔﺎﺘﻬﺎ، ﺩﻭﻥ ﺍﻟﺤﺎﺠﺔ ﺍﻟـﻰ ﺍﻟﻤـﺭﻭﺭ ﺒﻤﺴـﺠل‬

‫ﺍﻟﻨﻅﺎﻡ ﻜﻤﺎ ﻜﻨﺎ ﻨﻔﻌل ﺴﺎﺒﻘﺎ ﻤﻊ ‪ ،COM‬ﻭﻫﺫﺍ ﻴﻌﻨﻲ ﺍﻥ ﻋﻤﻠﻴﺔ ﺘﺜﺒﻴـﺕ ﺍﻟﺒـﺭﺍﻤﺞ ﻻ ﺘﺘﻁﻠـﺏ ﺠﻬـﺩ ﺍﻀـﺎﻓﻲ‬
‫ﻻﻨﺠﺎﺯﻫﺎ، ﻓﻴﻜﻔﻲ ﻨﺴﺦ ﺍﻟﻤﻠﻔﺎﺕ ﻤﻥ ﺍﻟﻘﺭﺹ ﺍﻟﻤﺩﻤﺞ ﺍﻟﻰ ﺍﻟﻘـﺭﺹ ﺍﻟﺼـﻠﺏ ﻭﺴـﻴﻌﻤل ﺍﻟﺒﺭﻨـﺎﻤﺞ ﺩﻭﻥ ﺃﻴـﺔ‬
‫ﻤﺸﺎﻜل، ﻤﻊ ﺫﻟﻙ ﻗﺩ ﺘﺤﺘﺎﺝ ﺍﻟﻰ ﺒﺭﺍﻤﺞ ﺍﻟﺘﺭﻜﻴﺏ ﻟﺘﻨﻔﻴﺫ ﺒﻌﺽ ﺍﻟﻠﻤﺴﺎﺕ ﺍﻟﺨﻔﻴﻔﺔ )ﻜﻭﻀﻊ ﺍﻟﻤﻠﻔﺎﺕ ﻓـﻲ ﺍﻤﺎﻜﻨﻬـﺎ‬

‫ﺍﻟﻤﻨﺎﺴﺒﺔ، ﺘﺨﺼﻴﺹ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﻤﻁﻠﻭﺏ ﺘﺜﺒﻴﺘﻬﺎ، ﺍﻋﺩﺍﺩﺍﺕ ﺒﺴﻴﻁﺔ ﻗﺒﻴل ﻋﻤﻠﻴﺔ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ....ﺍﻟﺦ(.‬

‫ﻭﺒﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﻜﻭﻨﺎﺕ ﺍﻟﻤﻭﺯﻋﺔ ‪ DCOM‬ﻓﻠﻥ ﺘﺤﺘﺎﺝ ﺍﻟﻰ ﺍﻟﻌﺒـﺙ ﻓـﻲ ﻨﻅـﺎﻡ ﺍﻟﺘﺸـﻐﻴل ‪Windows‬‬

‫ﻭﻤﺤﺘﻭﻴﺎﺕ ﺍﻟﻤﻜﻭﻥ ﻟﺘﺠﺭﻱ ﻋﺸﺭﺍﺕ ﺍﻻﻋﺩﺍﺩﺍﺕ ﺍﻻﻀﺎﻓﻴﺔ ﺤﺘﻰ ﻴـﺘﻡ ﺘﻭﺯﻴﻌـﻪ، ﺍﺫ ﺍﻥ ﻤﻜﻭﻨـﺎﺕ ‪ .NET‬ﻫـﻲ‬
‫ﻤﻭﺯﻋﺔ ﺒﺤﺩ ﺫﺍﺘﻬﺎ.‬

‫ﺃﻤﺎ ﻤﺸﻜﻠﺔ ﺍﻟﺘﻭﺍﻓﻘﻴﺔ ‪ Versioning‬ﻓﻠﻥ ﺘﺤﺩﺙ ﺒﻌﺩ ﺍﻻﻥ، ﺤﻴﺙ ﻴﻤﻜﻥ ﺘﺜﺒﻴﺕ ﺍﺼﺩﺍﺭﻴﻥ ﻤﺨﺘﻠﻔـﻴﻥ ﻤـﻥ‬

‫ﻨﻔﺱ ﺍﻟﻤﻜﻭﻥ ﺩﻭﻥ ﺍﻥ ﻴﺅﺜﺭ ﺍﺤﺩﻫﻤﺎ ﻋﻠﻰ ﺍﻻﺨﺭ.‬

‫ﻤﻴﺯﺓ ﻋﻅﻴﻤﺔ ﺃﺨﺭﻯ ﻓﻲ ﻤﻜﻭﻨﺎﺕ ‪ .NET‬ﻟﻡ ﺘﻜﻥ ﻤﺩﻋﻭﻤﺔ ﺴﺎﺒﻘﺎ ﻤﻊ ﻤﻜﻭﻨﺎﺕ ‪ COM‬ﻭﻫﻲ ﺍﻟﻭﺭﺍﺜـﺔ‬

‫‪ ،Inheritance‬ﻓﻤﻜﻭﻨﺎﺕ ‪ COM‬ﻟﻡ ﻴﻜﻥ ﻤﺘﺎﺤﺎ ﺍﺸﺘﻘﺎﻗﻬﺎ ﻭﺭﺍﺜﻴﺎ ﻭﺘﻁﻭﻴﺭ ﻓﺌﺎﺘﻬـﺎ، ﺍﻤـﺎ ﻤﻜﻭﻨـﺎﺕ ‪.NET‬‬
‫ﹰ‬
‫ﻓﻠﺩﻴﻙ ﺍﻟﻘﺩﺭﺓ ﺍﻟﻜﺎﻤﻠﺔ ﻻﺸﺘﻘﺎﻕ ﻓﺌﺎﺕ ﺍﻟﻤﻜﻭﻨﺎﺕ ﻭﺭﺍﺜﻴﺎ ﺩﻭﻥ ﺍﻟﺤﺎﺠﺔ ﻟﻠﺤﺼﻭل ﻋﻠﻰ ﺸﻴﻔﺭﺍﺘﻬﺎ ﺍﻟﻤﺼﺩﺭﻴﺔ.‬

‫ﺼﺤﻴﺢ ﺍﻥ ﻤﻜﻭﻨﺎﺕ ‪ COM‬ﻜﺎﻨﺕ ﺘﺯﻴل ﺤﺎﺠﺯ ﺍﻟﻔﺭﻭﻗﺎﺕ ﺒﻴﻥ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﺨﺘﻠﻔـﺔ، ﺍﻻ ﺍﻥ ﻫـﺫﺍ‬

‫ﺍﻟﺤﺎﺠﺯ ﻟﻡ ﻴﺘﻡ ﺍﺯﺍﻟﺘﻪ ﺒﺸﻜل ﻜﺎﻤل، ﻓﻤـﺎ ﺯﺍل ﻤﺒﺭﺠـﻭﺍ ﺒﻌـﺽ ﻟﻐـﺎﺕ ﺍﻟﺒﺭﻤﺠـﺔ )ﻜــ ‪(Visual Basic‬‬

‫ﻴﻭﺍﺠﻬﻭﻥ ﻤﺸﺎﻜل ﻭﺼﻌﻭﺒﺎﺕ ﻓﻲ ﺍﺴﺘﺨﺩﺍﻡ ﺒﻌﺽ ﻤﻜﻭﻨﺎﺕ ‪ COM‬ﺍﻟﻤﻨﺠﺯﺓ ﺒﻠﻐـﺎﺕ ﻤﺘﻘﺩﻤـﺔ ﺍﺨـﺭﻯ )ﻜــ‬
‫++‪ (Visual C‬ﺨﺎﺼﺔ ﻤﻊ ﺍﻟﻤﻜﻭﻨﺎﺕ ﺍﻟﺘﻲ ﺘﺘﻌﺎﻤل ﻤﻊ ﺍﻨﻭﺍﻉ ﺒﻴﺎﻨﺎﺕ ﻟﻴﺴﺕ ﻤﺩﻋﻭﻤـﺔ ﻓـﻲ ‪Visual Basic‬‬

‫) ﻜﺎﻟﻤﺅﺸﺭﺍﺕ ‪ Pointers‬ﻤﺜﻼ(، ﻭﻟﻜﻥ ﻤﻊ ﻤﻜﻭﻨﺎﺕ ‪ .NET‬ﺍﻤﺴﺕ ﻜل ﻫﺫﻩ ﺍﻟﺘﻌﺎﺭﻀـﺎﺕ ﻤـﻥ ﺍﻟﻤﺎﻀـﻲ،‬
‫ﻭﻤﺭﺩ ﺫﻟﻙ ﺍﻥ ﺠﻤﻴﻊ ﻟﻐﺎﺕ ‪ .NET‬ﻤﻭﺤﺩﺓ ﺒﻔﻀل ﻤﻌﺎﻴﻴﺭ ‪ CRL‬ﻜﻤﺎ ﺴﺘﺭﻯ ﻻﺤﻘﺎ.‬
‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮف ﻋﻠﻰ ‪V isual Basic .NET‬‬
‫11‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺗﻜﺎﻣﻞ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ‬
‫ﺠﻤﻴﻊ ﻟﻐﺎﺕ ‪ .NET‬ﻤﺘﻜﺎﻤﻠﺔ ﻓﻴﻤﺎ ﺒﻴﻨﻬﺎ، ﻓﺒﺭﻨﺎﻤﺠﻙ ﺍﻟﻤﺼﻤﻡ ﺒــ ‪ Visual Basic .NET‬ﻴﻤﻜـﻥ ﺍﻀـﺎﻓﺔ‬
‫ﺒﻌﺽ ﺍﻟﻌﻨﺎﺼﺭ ﻭﺍﻟﺸﻴﻔﺭﺍﺕ ﺍﻟﻤﺼﺩﺭﻴﺔ ﺇﻟﻴﻪ ﻤﻥ ﻟﻐـﺔ ‪ Visual C# .NET‬ﺩﻭﻥ ﺍﻱ ﻤﺸـﺎﻜل، ﺒـل ﻴﻤﻜـﻥ‬
‫ﻟﻠﻤﺸﺭﻭﻉ ﺍﻟﻭﺍﺤﺩ ﺍﻥ ﻴﺩﻤﺞ ﺸﻴﻔﺭﺍﺕ ﻤﺼﺩﺭﻴﺔ ﻤﻥ ﻟﻐـﺎﺕ ﻤﺘﻌـﺩﺩﺓ ﻤﺜـل: ‪،Java .NET ،Delphi .NET‬‬
‫‪) Turki .NET ،Visual C++ .NET‬ﺇﻥ ﻭﺠﺩﺕ(، ‪... ،Fortran .NET‬ﺍﻟﺦ ﻭﺫﻟﻙ ﺒﻔﻀـل ﻤﻌـﺎﻴﻴﺭ‬

‫‪ CRL‬ﺍﻟﺘﻲ ﺘﻭﺤﺩ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ.‬

‫ﻗﺩ ﺘﺘﺴﺎﺌل ﻭﺘﻘﻭل، ﻤﺎ ﺩﺍﻤﺕ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﺨﺘﻠﻔﺔ ﻤﻭﺤﺩﺓ ﺒﻬﺫﺍ ﺍﻟﺸﻜل ﻓﻤﺎ ﺍﻟﻔﺎﺌﺩﺓ ﻤـﻥ ﺘﻌﻠـﻡ ﺍﻜﺜـﺭ‬

‫ﻤﻥ ﻟﻐﺔ؟ ﻭﺍﻟﺠﻭﺍﺏ ﻫﻭ ﺍﻨﻪ ﻤﺎ ﺯﺍﻟﺕ ﻜل ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﺘﺤﺘﻭﻱ ﻋﻠﻰ ﺴﻤﺎﺕ ﻭﻤﻤﻴـﺯﺍﺕ ﺨﺎﺼـﺔ ﺒﻬـﺎ، ﻭﺍﻋﻨـﻲ‬
‫ﺒﻜﻠﻤﺔ ﺨﺎﺼﺔ ﺒﻬﺎ ﻓﻲ ﻫﺫﺍ ﺍﻟﺴﻴﺎﻕ ﻫﻭ ﻋﺩﻡ ﺍﻤﻜﺎﻨﻴﺔ ﺘﻜﺎﻤﻠﻬﺎ ﻤﻊ ﻟﻐﺎﺕ ‪ .NET‬ﺍﻻﺨـﺭﻯ ﺍﻥ ﺘـﻡ ﺘﻔﻌﻴـل ﻫـﺫﻩ‬
‫ﺍﻟﻤﺯﺍﻴﺎ. ﻤﻥ ﻨﺎﺤﻴﺔ ﺍﺨﺭﻯ، ﺠﻤﻴـﻊ ﻟﻐـﺎﺕ ‪ .NET‬ﻴـﺘﻡ ﺘﺤﻭﻴﻠﻬـﺎ ﺍﻟـﻰ ﻟﻐـﺔ ‪ MSIL‬ﻟﺤﻅـﺔ ﺍﻟﺘﺭﺠﻤـﺔ‬
‫‪ Compiling‬ﻜﻤﺎ ﺴﺘﺭﻯ ﻻﺤﻘﺎ.‬

‫ﺧﺪﻣﺎت وﻳﺐ هﻲ ﻣﺴﺘﻘﺒﻞ اﻻﻧﺘﺮﻧﺖ‬
‫ﻤﻨﺫ ﺍﻥ ﻨﺸﺒﻙ ﺴﻠﻙ ﺍﻟﻬﺎﺘﻑ ﻭﻨﺘﺼل ﺒﺎﻻﻨﺘﺭﻨﺕ، ﻓـﺈﻥ ﻤﻌﻅـﻡ ﻭﻗﺘﻨـﺎ ﻨﻘﻀـﻴﻪ ﻋﻠـﻰ ﺍﻟﻤﺘﺼـﻔﺢ ‪Browser‬‬
‫ﻟﻠﻭﺼﻭل ﺍﻟﻰ ﺍﻟﻤﻭﺍﻗﻊ ﺍﻟﻤﺨﺘﻠﻔﺔ، ﺍﻟﻔﻌل ﺍﻟﺴﺎﺒﻕ ﺴﻴﻜﻭﻥ ﻤﻥ ﺍﺴﺎﻁﻴﺭ ﺍﻻﻭﻟﻴﻥ ﻓﻲ ﺍﻟﻤﺴﺘﻘﺒل ﺍﻟﻘﺭﻴﺏ، ﻭﺫﻟـﻙ ﺒﻌـﺩ‬
‫ﺍﻨﺘﺸﺎﺭ ﺨﺩﻤﺎﺕ ﻭﻴﺏ ‪ Web Services‬ﺤﻴﺙ ﺴﺘﻐﻴﺭ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﺴﻠﻭﺏ ﺘﻌﺎﻤﻠﻨﺎ ﻤﻊ ﺸﺒﻜﺔ ﺍﻻﻨﺘﺭﻨـﺕ ﺒﻁـﺭﻕ‬

‫ﻟﻡ ﺘﺨﻁﺭ ﻋﻠﻰ ﺒﺎل ﺍﻨﺱ ﻭﻻ ﺠﺎﻥ. ﺍﻟﺠﺯﺀ ﺍﻟﺨﺎﻤﺱ ﺒﺭﻤﺠﺔ ﻭﻴﺏ ﻤﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻴﻘﺩﻡ ﻟﻙ ﺸﺭﺤﺎ ﻭﺍﻓﻴـﺎ ﺤـﻭل‬
‫ﹰ‬
‫ﹰ‬

‫ﺨﺩﻤﺎﺕ ﻭﻴﺏ، ﻭﻟﻜﻥ ﺩﻋﻨﻲ ﻫﻨﺎ ﺍﻋﺭﻑ ﻟﻙ ﻤﺎﻫﻲ ﺨﺩﻤﺔ ﻭﻴﺏ ‪ Web Service‬ﺒﺸﻜل ﺴﺭﻴﻊ.‬

‫ﺨﺩﻤﺔ ﻭﻴﺏ )ﺘﺴﻤﻰ ﺍﺤﻴﺎﻨﺎ ‪ (XML Web Service‬ﻤﺎﻫﻲ ﺍﻻ ﺒﺭﻨﺎﻤﺞ ﻴﺴـﺘﻘﺒل ﻁﻠﺒـﺎﺕ ‪Requests‬‬
‫ﻭﻤﻥ ﺜﻡ ﻴﺴﺘﺠﻴﺏ ﻟﻬﺎ ‪ Response‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﺒﺭﻭﺘﻭﻜﻭل ‪ TCP/IP‬ﺘﺤـﺕ ﻤﻌـﺎﻴﻴﺭ ﻟﻐـﺔ ‪ XML‬ﺍﻟﻘﻴﺎﺴـﻴﺔ،‬

‫ﻭﺒﺫﻟﻙ ﺘﺘﻤﻜﻥ ﻤﻼﻴﻴﻥ ﺍﻟﻤﻭﺍﻗﻊ ﺍﻟﻤﻨﺘﺸﺭﺓ ﺤﻭل ﺍﻟﻌﺎﻟﻡ ﻤـﻥ ﺘﺒـﺎﺩل ﺍﻟﺒﻴﺎﻨـﺎﺕ ﻓﻴﻤـﺎ ﺒﻴﻨﻬـﺎ ﻭﺍﻨﺠـﺎﺯ ﺍﺍﻷﻋﻤـﺎل‬
‫ﺍﻟﻤﻁﻠﻭﺒﺔ. ﻴﻤﻜﻨﻙ ﺍﻋﺘﺒﺎﺭ ﺨﺩﻤﺎﺕ ﻭﻴﺏ ﻋﻠﻰ ﺍﻨﻬﺎ ﺒﺭﻨﺎﻤﺞ ﻴﺘﺼـل ﺒﺎﻟﻌـﺎﻟﻡ ﺍﻟﺨـﺎﺭﺠﻲ ﻋـﻥ ﻁﺭﻴـﻕ ﺸـﺒﻜﺔ‬

‫ﺍﻻﻨﺘﺭﻨﺕ ﻤﻤﺎ ﻴﻤﻜﻨﻙ ﻤﻥ ﺍﺭﺴﺎل ﻭﺍﺴﺘﻘﺒﺎل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺼﻴﻐﺔ ‪ XML‬ﺩﻭﻥ ﺍﻥ ﻴﺘﻁﻠﺏ ﺍﻻﻤـﺭ ﻤﻨـﻙ ﺍﻱ ﺨﺒـﺭﺓ‬
‫ﻓﻲ ﻟﻐﺔ ‪ XML‬ﺍﻭ ﺒﺭﻭﺘﻭﻜﻭﻻﺕ ‪ ،TCP/IP‬ﺤﻴﺙ ﻴﻭﻓﺭ ﻟﻙ ﺍﻁﺎﺭ ﻋﻤل ‪ .NET Framework‬ﻜـل ﻤـﺎ‬

‫ﺘﺤﺘﺎﺠﻪ ﻟﺘﻁﻭﻴﺭ ﻭﺒﻨﺎﺀ ﺨﺩﻤﺎﺕ ﻭﻴﺏ.‬

‫ﺴﺘﻨﺘﺸﺭﺨﺩﻤﺎﺕ ﻭﻴﺏ ﺍﻨﺘﺸﺎﺭﺍ ﻻﻤﺜﻴل ﻟﻪ ﻓﻲ ﻤﻭﺍﻗﻊ ﺍﻻﻨﺘﺭﻨﺕ، )ﺴﻨﻭﻓﺭ ﺨﺩﻤﺔ ﻭﻴﺏ ﻓـﻲ ﻤﻭﻗـﻊ ﺸـﺒﻜﺔ‬
‫ﹰ‬
‫ﺍﻟﻤﻁﻭﺭﻭﻥ ﺍﻟﻌﺭﺏ ﺒﻤﺸﻴﺌﺔ ﺍﷲ(، ﺒل ﺴﺘﺼل ﺍﻟﻰ ﺘﻐﻴﻴﺭ ﻤﻌﻅﻡ ﺍﻻﻨﻅﻤﺔ ﺍﻟﺤﺎﻟﻴﺔ ﻟﺘﻌﺘﻤـﺩ ﻋﻠـﻰ ﺨـﺩﻤﺎﺕ ﻭﻴـﺏ‬

‫ﻭﺘﺼﺒﺢ ﻤﺅﺠﺭﺓ، ﻓﻴﻤﻜﻨﻙ ﻤﺜﻼ ﺘﻭﻓﻴﺭ ﺨﺩﻤﺔ ﻭﻴﺏ ﻟﻠﺘﺫﻜﻴﺭ ﺒﺎﻟﻤﻭﺍﻋﻴﺩ، ﺍﻭ ﺨﺩﻤﺔ ﺘﻭﻓﻴﺭ ﺍﺴﻌﺎﺭ ﺍﻟﻌﻤـﻼﺕ ﺍﻟﺘـﻲ‬
‫ﺘﺤﺩﺙ ﻋﻠﻰ ﻤﺩﺍﺭ ﺍﻟﺴﺎﻋﺔ، ﺍﻭ ﺨﺩﻤﺔ ﺍﻟﺤﺼﻭل ﻋﻠﻰ ﺩﺭﻭﺱ ﻭﻤﻘﺎﻻﺕ ﻤـﻥ ﻤﻭﻗـﻊ ﺍﺨـﺭ، ﺍﻭ ﺨﺩﻤـﺔ ﺒﺤـﺙ‬
‫ﻜﺨﺩﻤﺔ ‪... Google Search‬ﺍﻟﺦ.‬
‫21‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻣﺎذا ﻋﻦ اﻟﻤﺒﺮﻣﺞ اﻟﻌﺮﺑﻲ؟‬
‫ﺍﻁﺎﺭ ﻋﻤل ‪ .NET Framework‬ﻤﻭﺠﻪ ﺍﻟﻰ ﺠﻤﻴﻊ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺤﻭل ﺍﻟﻌﺎﻟﻡ ﺒـﺎﺨﺘﻼﻑ ﻟﻐـﺎﺘﻬﻡ ﺍﻟﻁﺒﻴﻌﻴـﺔ،‬
‫ﻭﺍﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ﺍﺤﺩﻯ ﻫﺫﻩ ﺍﻟﻠﻐﺎﺕ، ﻓﺎﻟﻨﺼﻭﺹ ﻤﺜﻼ ﺠﻤﻴﻌﻬﺎ ﺘﺘﺒﻊ ﺍﻟﺘﺭﻤﻴﺯ ‪ UNICODE‬ﻭﺘﻭﺯﻴـ ﻊ ﻤﺤـﺎﺭﻑ‬
‫ﻟﻭﺤﺎﺕ ﺍﻟﻤﻔﺎﺘﻴﺢ ﺍﻟﻌﺭﺒﻴﺔ ﻤﺄﺨﻭﺫ ﻓﻲ ﻋﻴﻥ ﺍﻻﻋﺘﺒﺎﺭ، ﻜﺫﻟﻙ ﺍﻟﺤﺎل ﻤـﻊ ﻤﻭﺍﺼـﻔﺎﺕ ﺍﻟﺒﻴﺌـﺔ ﻜﺘﻨﺴـﻴﻕ ﺍﻟﻌﻤﻠـﺔ،‬

‫ﺍﻟﻭﻗﺕ ﻭﺍﻟﺘﺎﺭﻴﺦ، ﺍﻻﺭﻗﺎﻡ، ﻨﻅﺎﻡ ﺍﻟﻔﺭﺯ ...ﺍﻟﺦ، ﻓﻬﻲ ﻤﺩﻋﻭﻤﺔ ﻟﺠﻤﻴﻊ ﺍﻟﺩﻭل ﺍﻟﻌﺭﺒﻴﺔ ﺒﺎﺴـﺘﺜﻨﺎﺀ -ﻤـﻊ ﺍﻻﺴـﻑ‬
‫ﺍﻟﺸﺩﻴﺩ - ﺍﻟﺴﻭﺩﺍﻥ، ﻓﻠﺴﻁﻴﻥ، ﺠﻴﺒﻭﺘﻲ، ﺍﻟﺼﻭﻤﺎل ﻭﻤﻭﺭﻴﺘﺎﻨﻴﺎ ﻓﻠﻡ ﺍﺠﺩﻫﺎ ﻓﻲ ﺍﺤـﺩ ﺭﻭﺍﺒـﻁ ﻤﺴـﺘﻨﺩﺍﺕ‬

‫‪.NET‬‬

‫‪ Documentation‬ﺍﻟﺭﺴﻤﻴﺔ.‬

‫ﻭﻋﻨﺩ ﺍﻟﺤﺩﻴﺙ ﻋﻥ ﺍﻟﻤﺴﺎﺌل ﺍﻟﺘﻘﻨﻴﺔ ﺍﻻﺨﺭﻯ، ﻓﺘﻘﻨﻴﺔ ﺍﻟﻤﺭﺁﺓ ‪ Mirroring‬ﻤﺩﻋﻭﻤـﺔ ﺒﺸـﻜل ﺠﻴـﺩ ﻓـﻲ‬

‫ﻨﻤﺎﺫﺝ ‪) Windows Forms‬ﻜﻤﺎ ﺴﺘﺭﻯ ﻓﻲ ﺍﻟﺠﺯﺀ ﺍﻟﺜﺎﻟﺙ ﺘﻁـﻭﻴﺭ ﺘﻁﺒﻴﻘـﺎﺕ ‪ ،(Windows‬ﻭﺒﺎﻟﻨﺴـﺒﺔ‬
‫ﻟﻠﺘﺎﺭﻴﺦ ﺍﻟﻬﺠﺭﻱ ﻓﻴﻭﻓﺭ ﻟﻙ ﺍﻁﺎﺭ ﻋﻤل ‪ .NET Framework‬ﺍﻟﻔﺌﺔ ‪ HijriCalendarClass‬ﺍﻟﺘﻲ ﺘﻤﻜﻨـﻙ‬
‫ﻤﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺘﺎﺭﻴﺦ ﺍﻟﻬﺠﺭﻱ ﻓﻲ ﺒﺭﺍﻤﺠﻙ ﻭﺘﻭﻓﺭ ﻟﻙ ﻁﺭﻕ ﻭﺨﺼﺎﺌﺹ ﻟﺘﻌﺩﻴل ﻭﻀـﺒﻁ ﺍﻟﻘﻴﻤـﺔ ﺍﻟﺼـﺤﻴﺤﺔ‬

‫ﻟﻠﻴﻭﻡ ﻭﺍﻟﺸﻬﺭ.‬

‫ﺒﺎﺨﺘﺼﺎﺭ، ﻭﻓﺭﺕ ‪ Microsoft‬ﻤﻨﺼﺔ ﺘﻁﻭﻴﺭ ﻗﻭﻴﺔ ﺘﺩﻋﻡ ﺍﻟﻠﻐـﺔ ﺍﻟﻌﺭﺒﻴـﺔ ﺒﺸـﻜل ﺭﺍﺌـﻊ، ﻟﺘﻨﺤﺼـﺭ‬

‫ﺍﻟﻤﺴﺅﻭﻟﻴﺔ ﻋﻠﻴﻨﺎ ﻨﺤﻥ ﻜﻌﺭﺏ –ﺴﻭﺍﺀ ﻓﻲ ﺸﺭﻜﺎﺕ ﻋﺭﺒﻴﺔ ﺍﻭ ﻤﻁﻭﺭﻭﻥ ﻋﺭﺏ - ﻟﺘﻘﺩﻴﻡ ﻜﺎﻓﺔ ﺍﻟﺤﻠـﻭل ﺍﻟﻔﻌﺎﻟـﺔ‬
‫ﻟﻠﻤﺴﺘﺨﺩﻡ ﺍﻟﻌﺭﺒﻲ.‬

‫ﻣﺤﺘﻮﻳﺎت اﻃﺎر اﻟﻌﻤﻞ ‪.NET Framework‬‬

‫ﻭﺍﻻﻥ ﺴﻴﺘﻤﺤﻭﺭ ﺤﺩﻴﺜﻲ ﺤﻭل ﻤﻌﻤﺎﺭﻴﺔ ﻭﻤﺤﺘﻭﻴﺎﺕ ﺍﻁﺎﺭ ﻋﻤـل ‪ ،.NET Framework‬ﻴﻤﻜﻨﻨـﻲ ﺍﻥ ﺍﻗﺴـﻡ‬
‫ﻟﻙ ﻤﺤﺘﻭﻴﺎﺘﻪ ﺍﻟﻰ ﺍﻜﺜﺭ ﻤﻥ 01 ﻁﺒﻘﺎﺕ، ﻭﻟﻜﻨﻲ ﻓﻀﻠﺕ ﺘﻘﻠﻴﺹ ﺍﻟﻌﺩﺩ –ﻟﻠﺘﺴـﻬﻴل ﻋﻠﻴـﻙ - ﻜﻤـﺎ ﺘـﺭﻯ ﻓـﻲ‬

‫)ﺍﻟﺸﻜل 1 -1(:‬

‫ﺸﻜل 1 -1: ﻤﺤﺘﻭﻴﺎﺕ ﺍﻁﺎﺭ ﻋﻤل ‪.NET Framework‬‬
‫ﻤﻜﺘﺒﺔ ﻓﺌﺎﺕ ‪) Base Class Library‬ﺘﺴﻤﻰ ﺍﻴﻀﺎ ﻤﻜﺘﺒـﺔ ﻓﺌـﺎﺕ ‪.NET Framework Class‬‬
‫‪ (Library‬ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﻤﺌﺎﺕ ﺍﻟﻔﺌﺎﺕ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﻋﺸﺭﺍﺕ ﻤﻠﻔﺎﺕ ‪ DLL‬ﺘﻌﺘﺒﺭ ﻜﻨﺯﺍ ﻏﺎﻟﻴـﺎ ﻴﺴـﻴل ﻟـﻪ‬
‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮف ﻋﻠﻰ ‪V isual Basic .NET‬‬
‫31‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻟﻌﺎﺏ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺍﻟﺠﺎﺩﻴﻥ، ﺤﻴﺙ ﺘﺤﻭﻱ ﻜل ﻤﺎ ﺘﺤﺘﺎﺠﻪ ﻻﻨﺠـﺎﺯ ﺒﺭﺍﻤﺠـﻙ ﻭﻤﺸـﺎﺭﻴﻌﻙ ﺒـﺩﺀﺍ ﺒﺘﻘـﺩﻴﻡ ﻓﺌـﺎﺕ‬
‫ﹰ‬
‫ﻟﻭﺼﻑ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻻﺴﺎﺴـﻴﺔ )ﻜــ ‪ (Integer ،String‬ﺍﻟـﻰ ﺍﺩﺍﺭﺓ ﺨـﺭﺝ ﻭﺩﺨـل ﺍﻟﻤﻠﻔـﺎﺕ ‪I/O File‬‬
‫‪ ،Processing‬ﻤﺴﺎﺭﺍﺕ ﺍﻟﺘﻨﻔﻴﺫ ‪ ،Threading‬ﺍﻟﺼﻭﺭ ﻭﺍﻟﺭﺴﻭﻡ، ﻨﻤـﺎﺫﺝ ‪ ،Windows Forms‬ﻨﻤـﺎﺫﺝ‬
‫‪ ،Web Forms‬ﺍﻻﺘﺼﺎل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ ADO .NET‬ﻭﻏﻴﺭﻫﺎ ﺍﻟﻜﺜﻴﺭ.‬
‫ﺒﺎﻟﻨﺴﺒﺔ ﻟﻠﻐﺔ ﺍﻟﺘﻨﻔﻴﺫ ﺍﻟﻤﺸﺘﺭﻜﺔ ‪ Common Language Runtime‬ﻓﻬﻲ ﻤﻭﺤـﺩﺓ ﻟﻤﻌـﺎﻴﻴﺭ ﺠﻤﻴـﻊ‬

‫ﻟﻐﺎﺕ ‪ .NET‬ﺍﻻﺨﺭﻯ، ﻜﻤﺎ ﺍﻨﻬﺎ ﺍﻟﻤﺴـﺅﻭﻟﺔ ﻋـﻥ ﻋﻤﻠﻴـﺎﺕ ﺍﺩﺍﺭﺓ ﺍﻟـﺫﺍﻜﺭﺓ ‪،Memory Management‬‬
‫ﺘﻔﺭﻴﻎ ﻤﺼﺎﺩﺭ ﺍﻟﻨﻅﺎﻡ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪ ،Garbage Collection‬ﺍﺨﻁﺎﺀ ﻭﻗـﺕ ﺍﻟﺘﻨﻔﻴـﺫ ‪Exception Handling‬‬
‫)ﺴﺄﺘﺤﺩﺙ ﻋﻥ ﻜل ﻤﺎ ﺫﻜﺭﺘﻪ ﻓﻲ ﺍﻟﻔﺼﻭل ﺍﻟﻼﺤﻘﺔ ﻤﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ(.‬

‫ﺍﺨﻴﺭﺍ، ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ﺍﻟﺫﻱ ﻴﻤﻜﻨﻙ ﻤـﻥ ﺘﺜﺒﻴـﺕ ﺍﻁـﺎﺭ ﻋﻤـل ‪ .NET Framework‬ﻋﻠﻴـﻪ ﻫـﻭ‬

‫‪ Windows‬ﻓﻘﻁ )ﻟﺤﻅﺔ ﻜﺘﺎﺒﺔ ﻫﺫﻩ ﺍﻟﺴﻁﻭﺭ(، ﻭﻟﻜﻥ ﻗﺩ ﺘﺭﻯ ﻓﻲ ﺍﻟﻘﺭﻴﺏ ﺍﻟﻌﺎﺠـل ﻨﻅـﻡ ﺘﺴـﻐﻴل ﺍﺨـﺭﻯ‬
‫ﺩﺍﻋﻤﺔ ﻟﻪ.‬

‫اﻟﺘﺮﺟﻤﺔ ﻋﻠﻰ اﻟﻔﻮر ‪JIT‬‬
‫ﻤﻥ ﺍﺠﻤل ﺍﻻﺸﻴﺎﺀ ﺍﻟﺘﻲ ﺴﺘﻜﺘﺸﻔﻬﺎ ﻭﺍﻟﺘﻲ ﺘﻌﺘﺒﺭ ﻓﺘﺢ ﻜﺒﻴﺭ -ﻓﻲ ﺭﺃﻴﻲ ﺍﻟﺸﺨﺼﻲ - ﻓﻲ ﻋـﺎﻟﻡ ﺒﺭﻤﺠـﺔ ‪.NET‬‬
‫ﻫﻭ ﺍﺴﻠﻭﺏ ﺍﻟﺘﺭﺠﻤﺔ ﻋﻠﻰ ﺍﻟﻔﻭﺭ ‪ ،(JIT ) - Just In Time Compiling‬ﻭﻫﻲ ﺘﻘﻨﻴﺔ ﺘﻘﻭﻡ ﺒﺘﺭﺠﻤـﺔ‬

‫ﺍﻟﺒﺭﻨﺎﻤﺞ ﻋﻨﺩ ﺘﻨﻔﻴﺫﻩ ﺤﻴﺙ ﻴﻨﺘﺞ ﺍﻓﻀل ﺸﻴﻔﺭﺓ ﺘﺘﻨﺎﺴﺏ ﻤﻊ ﺍﻟﺠﻬﺎﺯ ﺍﻟﺫﻱ ﺴﻴﻌﻤل ﻋﻠﻴﻪ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻤﻤﺎ ﻴﻨـﺘﺞ ﻋﻨـﻪ‬
‫ﻨﺘﺎﺌﺞ ﺍﻴﺠﺎﺒﻴﺔ ﺠﻴﺩﺓ ﺠﺩﺍ، ﻫﺫﺍ ﻋﻨﺩ ﺍﻟﺤﺩﻴﺙ ﻋﻥ ﺘﺤﺴﻴﻥ ﺍﻟﻜﻔﺎﺀﺓ ‪ ،Optimization‬ﻭﺤﺘﻰ ﺘﻌﻠـﻡ ﻜﻴـﻑ ﻴﺤـﺩﺙ‬
‫ﺫﻟﻙ ﺘﺎﺒﻊ )ﺍﻟﺸﻜل 1 -2(:‬

‫ﺸﻜل 1 -2: ﻤﺭﺍﺤل ﺘﺭﺠﻤﺔ ﻭﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ.‬
‫ﺍﺨﺘﺭ ﺍﻱ ﻟﻐﺔ ﺘﻨﺎﺴﺏ ﻤﺯﺍﺝ ﺍﻨﺎﻤﻠﻙ ﻭﺍﻜﺘﺏ ﺍﻟﺸﻴﻔﺭﺓ ﺒﻬﺎ، ﻭﻋﻨﺩ ﻗﻴﺎﻤﻙ ﺒﻌﻤﻠﻴﺔ ﺍﻟﺘﺭﺠﻤـﺔ ﺴـﻴﺘﻡ ﺘﺤﻭﻴـل‬
‫ﻤﻠﻑ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﻰ ﻤﻠﻑ ﺸـﺒﻴﻪ ﺒﺎﻟﻤﻠﻔـﺎﺕ ﺍﻟﺘﻨﻔﻴﺫﻴـﺔ ‪ Executable File‬ﻤﻜﺘـﻭﺏ ﺒﻠﻐـﺔ ﺠﺩﻴـﺩﺓ ﺍﺴـﻤﻬﺎ‬
‫41‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫‪) Microsoft Intermediate Language‬ﺘﺨﺘﺼـﺭ ‪ IL‬ﺍﻭ ‪ .(MSIL‬ﺤﻴـﺙ ﺘﺤﺘـﻭﻱ ﻋﻠـﻰ ﺸـﻴﻔﺭﺍﺕ‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻟﻜﻨﻬﺎ ﻏﻴﺭ ﻗﺎﺒﻠﺔ ﻟﻠﺘﻨﻔﻴﺫ ﻤﺒﺎﺸﺭﺓ، ﺒل ﻴﺸﺘﺭﻁ ﻭﺠﻭﺩ ﻤﺘﺭﺠﻡ ﻋﻠﻰ ﺍﻟﻔﻭﺭ ‪ JIT‬ﺤﻴـﺙ ﻴﻘـﻭﻡ ﺒﺘﺭﺠﻤـﺔ‬
‫ﻫﺫﺍ ﺍﻟﻤﻠﻑ ﺍﻟﺜﻨﺎﺌﻲ ﺍﻟﻰ ﻟﻐﺔ ﺍﻻﻟﺔ ﻤﻌﻁﻴﺎ ﺍﻓﻀل ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺒﺤﻴﺙ ﺘﻨﺎﺴـﺏ ﺍﻟﺠﻬـﺎﺯ ﺍﻟﺤـﺎﻟﻲ، ﻓﻌﻨـﺩﻤﺎ ﺘﺼـﻤﻡ‬

‫ﺒﺭﻨﺎﻤﺠﻙ ﻤﺭﺓ ﻭﺍﺤﺩﺓ ﻓﻘﻁ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪ Visual Basic .NET‬ﻓﺎﻋﻠﻡ ﺍﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺴﻴﺴﺘﻔﻴﺩ ﻤﻥ ﻜـل ﻤﺼـﺎﺩﺭ‬
‫ﺍﻟﻌﺘﺎﺩ ﻭﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ﺍﻟﺫﻱ ﻴﺘﻡ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻓﻴﻪ، ﺍﻱ ﻟﻭ ﺸﻐﻠﺕ ﺒﺭﻨﺎﻤﺞ ﺘﺤﺕ ﺨـﺎﺩﻡ ‪ Server‬ﻴﺤﺘـﻭﻱ ﻋﻠـﻰ‬
‫2950740528734059 ﻤﻌﺎﻟﺞ ﻓﺜﻕ ﺜﻘﺔ ﺘﺎﻤﺔ ﺍﻥ ﺒﺭﻨﺎﻤﺠﻙ ﺴﻴﺴﺘﻔﻴﺩ ﻤﻥ ﻜل ﻫﺫﻩ ﺍﻟﻤﻌﺎﻟﺠﺎﺕ ﺭﻏﻡ ﺍﻨـﻙ ﻟـﻡ‬

‫ﺘﻬﺘﻡ ﺒﻬﺫﻩ ﺍﻟﻨﻘﻁﺔ ﻋﻠﻰ ﺍﻷﺭﺠﺢ.‬

‫ﻋﻤﻠﻴﺔ ﺍﻟﺘﺭﺠﻤﺔ ‪ JIT‬ﺘﻘﻭﻡ ﺒﺘﺭﺠﻤﺔ ﻜل ﺠﺯﺀ ﻤﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻋﻨﺩ ﺍﻟﺤﺎﺠـﺔ ﺍﻱ ﻋﻨـﺩ ﺍﺴـﺘﺩﻋﺎﺀ ﻭﻅﻴﻔـﺔ‬

‫ﻤﻌﻴﻨﻪ ﻓﻴﻪ، ﻭﻴﻤﻜﻨﻙ ﺘﺭﺠﻤﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻤﻥ ﺍﻭﻟﻪ ﺍﻟﻰ ﺍﺨﺭﻩ ﺍﻴﻀﺎ ﻋﻥ ﻁﺭﻴﻕ ﻤﺘـﺭﺠﻡ ﺍﺨـﺭ ﻴﺴـﻤﻰ ‪Native‬‬
‫‪) (NGEN) – Image Generator‬ﻴﺴﻤﻰ ﺍﻴﻀﺎ ‪ (Pre-JIT Compiler‬ﻤﻊ ﻤﻌﺭﻓﺔ ﺍﻥ ﺍﻟﺘﺭﺠﻤـﺔ ﺘـﺘﻡ‬

‫ﻤﺭﺓ ﻭﺍﺤﺩﺓ ﻓﻘﻁ، ﻭﻟﻥ ﻴﺸﻌﺭ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺒﺄﻱ ﺒﻁﺀ ﻓﻲ ﻋﻤﻠﻴﺔ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻋﻨﺩ ﺘﺸـﻐﻴﻠﻪ ﻤـﺭﺓ ﺍﺨـﺭﻯ، ﻓﻘـﺩ‬
‫ﺘﻤﺕ ﺘﺭﺠﻤﺘﻪ ﺒﺎﻟﺸﻜل ﺍﻟﻤﻨﺎﺴﺏ ﻟﺠﻬﺎﺯﻩ.‬

‫اﻟﻤﺠﻤﻌﺎت ‪Assemblies‬‬
‫ﺍﻟﻤﺠﻤﻊ ‪ Assembly‬ﻤﺎ ﻫﻭ ﺍﻻ ﻤﻠﻑ ) ﻗﺩ ﻴﻜﻭﻥ ‪ EXE‬ﺍﻭ ‪ (DLL‬ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﻜل ﺸﺊ ﻴﺘﻌﻠـﻕ ﺒﺎﻟﺒﺭﻨـﺎﻤﺞ‬

‫ﺴﻭﺍﺀ ﺸﻴﻔﺭﺍﺘﻪ ﺍﻟﻤﺼﺩﺭﻴﺔ ﺒﻌﺩ ﺍﻟﺘﺭﺠﻤﺔ ‪ ،Compiling‬ﺍﻟﺼﻭﺭ ﻭﺍﻟﺭﺴﻭﻡ، ﻤﻠﻔـﺎﺕ ﺍﻟﻤﺼـﺎﺩﺭ‬

‫‪Resource‬‬

‫‪ ،Files‬ﺼﻔﺤﺎﺕ ‪ ،HTML‬ﻭﻏﻴﺭﻫﺎ. ﻜل ﻫﺫﻩ ﺍﻟﻌﻨﺎﺼﺭ ﻴﻤﻜﻨﻙ ﺍﻥ ﺘﻀﻌﻬﺎ ﺠﻤﻴﻌﺎ ﻓﻲ ﻤﻠﻑ ﻭﺍﺤﺩ ﻓﻘﻁ.‬

‫ﻓﻲ ﺍﻏﻠﺏ ﺍﻻﺤﻭﺍل، ﻴﻤﺜل ﺍﻟﻤﺠﻤﻊ ﺒﺭﻨﺎﻤﺞ ﻭﺍﺤﺩ، ﻤـﻊ ﺫﻟـﻙ ﻴﻤﻜـﻥ ﻟﻠﻤﺠﻤﻌـﺎﺕ ‪ Assemblies‬ﺍﻥ‬

‫ﺘﺤﺘﻭﻱ ﻋﻠﻰ ﻤﺠﻤﻌﺎﺕ ﺍﺨﺭﻯ، ﺍﻱ -ﺒﻌﺒﺎﺭﺓ ﺃﺨﺭﻯ - ﻴﻤﻜﻥ ﻟﺒﺭﻨﺎﻤﺠﻙ ﺍﻥ ﻴﺩﻤﺞ ﻓﻲ ﺩﺍﺨﻠـﻪ ﺒﺭﻨـﺎﻤﺞ ﺁﺨـﺭ -‬
‫ﻜﻤﺎ ﺴﺘﺭﻯ ﻻﺤﻘﺎ ﻓﻲ ﺍﻟﻔﺼل ﺍﻟﺤﺎﺩﻱ ﻋﺸﺭ ﺍﻟﻤﺠﻤﻌﺎﺕ ‪.Assemblies‬‬

‫ﺍﺨﻴﺭﺍ، ﻜل ﻤﺎ ﺫﻜﺭﺘﻪ ﻤﻥ ﺠﻤل ﻭﻋﺒﺎﺭﺍﺕ ﻤﺒﻬﻤﺔ ﻓـﻲ ﺍﻟﻔﻘـﺭﺍﺕ ﺍﻟﺴـﺎﺒﻘﺔ، ﺴـﺎﻋﻭﺩ ﻟﻠﺤـﺩﻴﺙ ﻋﻨﻬـﺎ‬
‫ﺒﺎﻟﺘﻔﺼﻴل ﺍﻟﻤﻤل ﻓﻲ ﺒﺎﻗﻲ ﻓﺼﻭل ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ، ﻓﻠﺴﺕ ﺒﺤﺎﺠﺔ ﻻﻥ ﺘﻜﻭﻥ ﻤﺴﺘﻭﻋﺒﺎ ﻟﻜل ﺸـﺊ ﺍﻵﻥ، ﺍﺫ ﺍﻥ ﻜـل‬
‫ﻤﺎ ﻜﻨﺕ ﺍﺭﻴﺩﺓ ﺍﻵﻥ ﻫﻭ ﺘﻘﺩﻴﻡ ﺠﻭﻟﺔ ﺴﺭﻴﻌﺔ ﺤﻭل ﻤﺤﺘﻭﻴﺎﺕ ﺍﻁﺎﺭ ﻋﻤل ‪.NET Framework‬‬

‫ﺑﻴﺌﺔ اﻟﺘﻄﻮﻳﺮ ‪Visual Studio .NET‬‬
‫ﻗﺩ ﺍﻏﻴﺭ ﺍﻟﻌﺭﻑ ﺍﻟﻤﺘﺒﻊ ﻓﻲ ﻜﺘﺏ ﺍﻟﺒﺭﻤﺠﺔ )ﻭﺍﻟﺘﻲ ﺘﺒﺩﺃ ﺒﺸﺭﺡ ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ ﺒﺎﻟﺘﻔﺼﻴل(، ﻭﻟﻜـﻥ ﻤـﻥ ﻤﻨﻁﻠـﻕ‬

‫ﺍﻴﻤﺎﻨﻲ ﺍﻟﺸﺩﻴﺩ ﺒﺎﻥ ﺍﻟﺸﺨﺹ –ﺍﻟﺫﻱ ﻴﻘﺭﺃ ﻜﺘﺎﺒﻲ - ﻫﻭ ﻤﺒﺭﻤﺞ ﻭﻟﻴﺱ ﻤﺴﺘﺨﺩﻡ، ﻓﺎﻋﺘﻘـﺩ ﺍﻨـﻪ ﻗـﺩ ﻭﺼـل ﺍﻟـﻰ‬
‫ﻤﺭﺤﻠﺔ ﺘﻤﻜﻨﻪ ﻤﻥ ﺘﻌﻠﻴﻡ ﻨﻔﺴﻪ ﺫﺍﺘﻴﺎ ﻻﺴﺘﺨﺩﺍﻡ ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ. ﻟﺫﻟﻙ، ﺍﻟﺘﻤﺱ ﻤﻨـﻙ ﺍﻟﻌـﺫﺭ ﺍﻟﺸـﺩﻴﺩ ﻴـﺎ ﻋﺯﻴـﺯﻱ‬

‫ﺍﻟﻘﺎﺭﺉ ﻓﻲ ﻤﺴﺎﻟﺔ ﺸﺭﺡ ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ، ﻓﻠﻥ ﺘﺠﺩ ﻫﻨﺎ ﺍﻻ ﻋﺭﺽ ﺴﺭﻴﻊ ﻭﻤﺨﺘﺼﺭ ﻟـﺒﻌﺽ ﻤﺤﺘﻭﻴـﺎﺕ ﺍﻟﺒﻴﺌـﺔ.‬
‫ﻤﻊ ﺫﻟﻙ، ﻗﺩ ﺍﺘﻁﺭﻕ ﻓﻲ ﻓﺼﻭل ﻻﺤﻘﺔ ﺍﻟﻰ ﺘﻔﺼﻴل ﺒﻌﺽ ﺍﻟﻨﻭﺍﻓﺫ ﻤﺘﻰ ﻤﺎ ﺩﻋﺕ ﺍﻟﺤﺎﺠﺔ ﻟﺫﻟﻙ.‬

‫ﺘﺘﺸﺎﺭﻙ ﻤﻌﻅﻡ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ) ‪Visual C++ ،Visual C#.NET ،Visual Basic .NET‬‬

‫‪ .NET‬ﻭﻏﻴﺭﻫﺎ( ﻓﻲ ﺒﻴﺌﺔ ﺘﻁﻭﻴﺭ ﻤﺘﻜﺎﻤﻠﺔ ﻤﻥ ‪ Microsoft‬ﺘﺴﻤﻰ ‪ ،Visual Studio. NET‬ﺤﻴﺙ ﺘـﻭﻓﺭ‬
‫ﻟﻙ ﻜل ﻤﺎ ﺘﺤﺘﺎﺠﻪ ﻤﻥ ﺨﺩﻤﺎﺕ ﻭﺍﺩﻭﺍﺕ ﻓﻲ ﻗﻤﺔ ﺍﻟﺭﻭﻋﺔ ﺘﺴﻬل ﻟﻙ ﺤﻴﺎﺘﻙ ﺍﻟﺒﺭﻤﺠﻴﺔ. ﺸﺭﺡ ﺠﻤﻴـﻊ ﻤﺤﺘﻭﻴـﺎﺕ‬
‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮف ﻋﻠﻰ ‪V isual Basic .NET‬‬
‫51‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫‪ Visual Studio .NET‬ﻴﺘﻁﻠﺏ –ﺩﻭﻥ ﻤﺒﺎﻟﻐﺔ - ﻜﺘﺎﺏ ﻜﺎﻤل، ﻭﻗﺩ ﺍﺼﺩﺭﺕ ﺒﺎﻟﻔﻌـل ‪Microsoft Press‬‬
‫ﻜﺘﺎﺒﺎ ﻴﺸﺭﺡ ﻜل ﺼﻐﻴﺭﺓ ﻭﻜﺒﻴﺭﺓ ﺤﻭل ﻫﺫﻩ ﺍﻟﺒﻴﺌﺔ، ﺍﻤﺎ ﺍﻟﻜﺘﺎﺏ ﺍﻟـﺫﻱ ﺘ ﻘـﺭﺃﻩ ﻓﻬـﻭ ﻴﺘﻌﻠـﻕ ﺒﻠﻐـﺔ ﺍﻟﺒﺭﻤﺠـﺔ‬
‫‪ Visual Basic .NET‬ﻓﻘﻁ، ﻭﻟﻥ ﺍﺫﻜﺭ ﺍﻻ ﺍﻟﻨﻭﺍﻓﺫ ﻭﺍﻻﺩﻭﺍﺕ ﺍﻟﺘﻲ ﺴﺘﺴﺘﺨﺩﻤﻬﺎ ﺒﺎﺨﺘﺼﺎﺭ ﻫﻨﺎ.‬

‫ﻧﻮاﻓﺬ ﺑﻴﺌﺔ اﻟﺘﻄﻮﻳ ﺮ‬

‫ﻋﻨﺩ ﺘﺸﻐﻴل ﺒﻴﺌﺔ ‪ Visual Studio .NET‬ﻻﻭل ﻤﺭﺓ، ﻤﺴﺘﻅﻬﺭ ﻟﻙ ﺍﻟﻨﺎﻓـﺫﺓ ‪) Start Page‬ﺸـﻜل 1 -3(،‬

‫ﺘﺴﺘﻁﻴﻊ ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﺍﺨﺭ ﻤﺸﺎﺭﻴﻊ ﺘﻡ ﻓﺘﺤﻬﺎ ﺍﻭ ﺍﻨﺸﺎﺀ ﻤﺸﺎﺭﻴﻊ ﺠﺩﻴﺩﺓ ﻋﻥ ﻁﺭﻴﻕ ﻫـﺫﻩ ﺍﻟﻨﺎﻓـﺫﺓ، ﻜﻤـﺎ ﺍﻨـﻙ‬
‫ﺘﺴﺘﻁﻴﻊ ﺍﻟﻭﺼﻭل ﺍﻟـﻰ ﺍﺨـﺭ ﺍﻻﺨﺒـﺎﺭ ﺍﻟﻤﺘﻌﻠﻘـﺔ ﺒــ ‪ .NET Framework‬ﺒﺎﻟﻀـﻐﻁ ﻋﻠـﻰ ﺍﻟـﺭﺍﺒﻁ‬
‫‪ Headlines‬ﻭﺫﻟﻙ ﻻﻥ ﺍﻟﻨﺎﻓﺫﺓ ‪ Start Page‬ﻤﺎﻫﻲ ﺍﻻ ﺼﻔﺤﺔ ﻭﻴﺏ ﺘﻘﻠﻴﺩﻴﺔ.‬

‫ﺸﻜل 1 -3: ﺍﻟﺸﺎﺸﺔ ﺍﻻﻓﺘﺘﺎﺤﻴﺔ ﻟﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ ‪.Visual Studio .NET‬‬
‫ﻨﺎﻓﺫﺓ ﺍﻟﺨﻴﺎﺭﺍﺕ ‪:Options‬‬
‫ﺍﺨﺘﻴﺎﺭﻙ ﻟﻼﻤﺭ ‪ Options‬ﻤﻥ ﻗﺎﺌﻤﺔ ‪ Tools‬ﻴﺅﺩﻱ ﺍﻟﻰ ﻅﻬﻭﺭ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ )ﺍﻟﺸﻜل 1 -4(، ﺤﻴـﺙ ﺘﻤﻜﻨـﻙ‬
‫ﻤﻥ ﺘﺨﺼﻴﺹ ﻭﺍﻋﺩﺍﺩ ﻋﺸﺭﺍﺕ ﺍﻻﻭﻀـﺎﻉ ﻭﺍﻟﺨﻴـﺎﺭﺍﺕ ﻜﺎﻋـﺩﺍﺩﺍﺕ ﺒﻴﺌـﺔ ﺍﻟﺘﻁـﻭﻴﺭ، ﻤﺤـﺭﺭ ﺍﻟﺸـﻴﻔﺭﺍﺕ،‬

‫ـﺎﺕ ‪ ،Database‬ﺍﻟﺘﻨﻘـﻴﺢ ‪ ،Debugging‬ـﺭﺭ ـﻔﺤﺎﺕ‬
‫ﻤﺤـ ﺼـ‬
‫ـﺩ ﺍﻟﺒﻴﺎﻨـ‬
‫ﺍﻟﻤﺘﺭﺠﻤـﺎﺕ ‪ ،Compilers‬ﻗﻭﺍﻋـ‬
‫‪ ،HTML‬ﻤﺼﻤﻡ ﻨﻤﺎﺫﺝ ‪ Windows Forms‬ﻭﻏﻴﺭﻫﺎ.‬
‫61‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺸﻜل 1 -4: ﻨﺎﻓﺫﺓ ﺍﻟﺨﻴﺎﺭﺍﺕ ‪.Options‬‬
‫ﻨﺎﻓﺫﺓ ﻋﺭﺽ ﺍﻟﻔﺌﺎﺕ ‪:Class View‬‬
‫ﺍﻟﻐﺭﺽ ﺍﻟﺭﺌﻴﺴﻲ ﻤﻥ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻫﻭ ﻋﺭﺽ ﻓﺌﺎﺕ ﺍﻟﺒﺭﻨـﺎﻤﺞ ‪ Project Classes‬ﻋﻠـﻰ ﺸـﻜل ﺸـﺠﺭﻱ‬

‫)ﺍﻟﺸﻜل 1 -5(، ﻤﻊ ﺍﻟﻌﻠﻡ ﺍﻥ ﺍﻟﻔﺌﺎﺕ ﺍﻟﺘﻲ ﺘﻌﺭﺽ ﻓﻲ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻫﻲ ﺍﻟﻔﺌﺎﺕ ﺍﻟﺘـﻲ ﺘﻌﺭﻓﻬـﺎ ﻓـﻲ ﺍﻟﺸـﻴﻔﺭﺓ‬
‫ﺍﻟﻤﺼﺩﺭﻴﺔ ﻟﻠﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ ﻓﻘﻁ، ﻓﻼ ﺘﺘﻭﻗﻊ ﻅﻬﻭﺭ ﻓﺌﺎﺕ ﻤﻥ ﻤﻜﺘﺒﺎﺕ ﺍﺨﺭﻯ ﻟﻡ ﻴـﺘﻡ ﺘﻀـﻤﻴﻨﻬﺎ ﻓـﻲ ﻨﻔـﺱ‬
‫ﺍﻟﻤﺸﺭﻭﻉ.‬

‫ﺸﻜل 1 -5: ﻨﺎﻓﺫﺓ ﻋﺭﺽ ﺍﻟﻔﺌﺎﺕ ‪Class View‬‬
‫ﺍﻟﻀﻐﻁ ﺍﻟﻤﺯﺩﻭﺝ ﻋﻠﻰ ﻋﻨﺼﺭ ﻤﻥ ﻋﻨﺎﺼﺭ ﻫﺫﻩ ﺍﻟﺸﺠﺭﺓ، ﻴﺅﺩﻱ ﺍﻟﻰ ﻓﺘﺢ ﻨﺎﻓﺫﺓ ﺍﻟﻤﺤﺭﺭ ﻭﻨﻘل ﻤﺅﺸـﺭ ﺍﻟﻜﺘﺎﺒـﺔ‬
‫‪ Cursor‬ﺍﻟﻰ ﻤﻨﻁﻘﺔ ﺘﻌﺭﻴﻑ ﺍﻟﻔﺌﺔ ﺍﻭ ﺍﻟﻌﻀﻭ ﻓﻲ ﺍﻟﻔﺌﺔ. ﺍﺨﺘﺭ ﺍﻻﻤـﺭ ‪ Class View‬ﻤـﻥ ﻗﺎﺌﻤـﺔ ‪View‬‬
‫ﻟﻌﺭﺽ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ.‬
‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮف ﻋﻠﻰ ‪V isual Basic .NET‬‬
‫71‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻨﺎﻓﺫﺓ ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤل ‪:Solution Explorer‬‬
‫ﺍﻥ ﻜﺎﻨﺕ ﻨﺎﻓﺫﺓ ﻋﺭﺽ ﺍﻟﻔﺌﺎﺕ ﺍﻟﺴﺎﺒﻘﺔ ﺘﻌﺭﺽ ﻓﺌﺎﺕ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ، ﻓﺎﻥ ﻨﺎﻓﺫﺓ ﻤﺴﺘﻜﺸـﻑ ﺍﻟﺤـل ﺘﻌـﺭﺽ‬
‫ﻤﻠﻔﺎﺕ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ ﻭﺍﻟﻤﺸﺎﺭﻴﻊ ﺍﻻﺨﺭﻯ )ﺸﻜل 1 -6(. ﺍﺨﺘﺭ ﺍﻻﻤﺭ ‪ Solution Explorer‬ﻤﻥ ﻗﺎﺌﻤـﺔ‬

‫‪ View‬ﻟﻌﺭﺽ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ.‬

‫ﺸﻜل 1 -6: ﻨﺎﻓﺫﺓ ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤل ‪Solution Explorer‬‬
‫ﻓﻲ ﺍﻋﻠﻰ ﺸﺠﺭﺓ ﻤﻠﻔﺎﺕ ﺍﻟﻤﺸﺭﻭﻉ ﺘﻼﺤﻅ ﻭﺠﻭﺩ ﻋﻨﺼﺭ ﺍﻟﻤﺭﺍﺠﻊ ‪ ،References‬ﻴﻘﺼـﺩ ﺒﻬـﺫﻩ ﺍﻟﻤﺭﺍﺠـﻊ:‬
‫ﺍﻟﻤﻜﺘﺒﺎﺕ ﺍﻟﺨﺎﺭﺠﻴﺔ ﺍﻟﺘﻲ ﺘﺭﻴﺩ ﺘﻀﻤﻴﻨﻬﺎ ﻓﻲ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ ﻭﺍﻟﻭﺼﻭل ﺍﻟـﻰ ﻓﺌﺎﺘﻬـﺎ، ﺍﻨﻘـﺭ ﺒـﺯﺭ ﺍﻟﻔـﺄﺭﺓ‬
‫ﺍﻻﻴﻤﻥ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻭﺍﺨﺘﺭ ﺍﻻﻤﺭ ‪ Add Reference‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻤﻨﺒﺜﻘﺔ، ﻟﺘﻅﻬﺭ ﻟﻙ ﻨﺎﻓـﺫﺓ ﺍﻟﻤﺭﺍﺠـﻊ‬

‫)ﺸﻜل 1 -7(.‬

‫ﺸﻜل 1 -7: ﻨﺎﻓﺫﺓ ﺍﻟﻤﺭﺍﺠﻊ ‪.Reference‬‬
‫81‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻤﻊ ﺍﻨﻪ ﻴﻤﻜﻨﻙ ﺍﻀﺎﻓﺔ ﺍﻭ ﺤﺫﻑ ﺍﻟﻤﺭﺍﺠﻊ ﻤﻥ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ.‬
‫ﻨﺎﻓﺫﺓ ﺨﺼﺎﺌﺹ ﺍﻟﻤﺸﺭﻭﻉ ‪:Project Property Pages‬‬
‫ﻋﻨﺩ ﺍﻟﺒﺩﺀ ﻓﻲ ﺍﻨﺸﺎﺀ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ، ﻴﻨﺼﺢ ﺩﺍﺌﻤﺎ ﺒﺘﻌﺩﻴل ﺍﻋﺩﺍﺩﺍﺕ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻭﻻ ﻋـﻥ ﻁﺭﻴـﻕ ﻫـﺫﻩ ﺍﻟﻨﺎﻓـﺫﺓ،‬
‫ﺘﺴﺘﻁﻴﻊ ﺍﻟﻭﺼﻭل ﻟﻬﺎ ﺒﺎﻟﻨﻘﺭ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻻﻴﻤﻥ ﻋﻠﻰ ﻋﻨﺼﺭ ﺍﻟﻤﺸﺭﻭﻉ ﻓﻲ ﻨﺎﻓﺫﺓ ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤل )ﺸـﻜل 1 -‬
‫6( ﻭﻤﻥ ﺜﻡ ﺍﺨﺘﻴﺎﺭ ﺍﻻﻤﺭ ‪ Properties‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻤﻨﺒﺜﻘﺔ ﻟﺘﻅﻬﺭ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ )ﺸـﻜل 1 -8( ﺍﻜﺘـﺏ ﺍﺴـﻡ‬

‫ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ ﺘﺤﺕ ﺨﺎﻨﺔ ‪.Assembly Name‬‬

‫ﺸﻜل 1 -8: ﻨﺎﻓﺫﺓ ﺨﺼﺎﺌﺹ ﺍﻟﻤﺸﺭﻭﻉ.‬
‫ﻨﺎﻓﺫﺓ ﻤﺴﺘﻌﺭﺽ ﺍﻟﻜﺎﺌﻨﺎﺕ:‬
‫ﺍﺫﺍ ﺍﺭﺩﺕ ﻤﻌﺭﻓﺔ ﺠﻤﻴﻊ ﺍﻟﻔﺌﺎﺕ ﻭﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻭﺍﻻﻋﻀﺎﺀ ﺍﻟﺘﺎﺒﻌﺔ ﻟﻬﺎ ﺴﻭﺍﺀ ﻜﺎﻨـﺕ ﻫـﺫﻩ ﺍﻟﻔﺌـﺎﺕ ﻤﻌﺭﻓـﺔ ﻓـﻲ‬
‫ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺤـﺎﻟﻲ ﺍﻭ ﻤﻀـﻤﻨﺔ ﻤـﻥ ﻗﺎﺌﻤـﺔ ﺍﻟﻤﺭﺍﺠـﻊ ‪ ،Reference‬ﻓـﺎﺨﺘﺭ ﺍﻻﻤـﺭ ‪View->Other‬‬

‫‪ Windows->Object Browser‬ﻟﻌﺭﺽ ﻨﺎﻓﺫﺓ ﻤﺴﺘﻌﺭﺽ ﺍﻟﻜﺎﺌﻨﺎﺕ )ﺍﻟﺸﻜل 1 -9(‬
‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮف ﻋﻠﻰ ‪V isual Basic .NET‬‬
‫91‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺸﻜل 1 -9: ﻨﺎﻓﺫﺓ ﻤﺴﺘﻜﺸﻑ ﺍﻟﻜﺎﺌﻨﺎﺕ.‬
‫ﻨﺎﻓﺫﺓ ﻤﺤﺭﺭ ﺍﻟﺸﻴﻔﺭﺓ ‪:Code Editor‬‬

‫ﺘﻭﻓﺭ ﻨﺎﻓﺫﺓ ﻤﺤﺭﺭ ﺍﻟﺸﻴﻔﺭﺓ )ﺍﻟﺸﻜل 1 -01( ﻗﺎﺌﻤﺔ ‪ IntelliSense‬ﻭﺍﻟﺘﻲ ﺘﻅﻬﺭ ﺒﻤﺠـﺭﺩ ﻜﺘﺎﺒـﺔ ﺍﻟﻨﻘﻁـﺔ "."‬
‫ﺒﻌﺩ ﺍﺴﻡ ﺍﻟﻜﺎﺌﻥ ﻟﺘﻌﺭﺽ ﺠﻤﻴﻊ ﺍﻋﻀﺎﺌﻪ، ﻜﻤﺎ ﺘﻭﺠﺩ ﻓﻲ ﺍﻋﻠﻰ ﻨﺎﻓﺫﺓ ﺍﻟﻤﺤﺭﺭ ﻗﺎﺌﻤﺘﻴﻥ ﺍﻻﻭﻟـﻰ ﻟﻨﻘـل ﺍﻟﻤﺅﺸـﺭ‬
‫ﺍﻟﻰ ﺍﻟﻔﺌﺎﺕ ﻭﺍﻟﻭﺤﺩﺍﺕ ﺍﻟﺒﺭﻤﺠﻴﺔ ﻓﻲ ﺍﻟﻤﻠﻑ ﺍﻟﺤﺎﻟﻲ، ﻭﺍﻟﺜﺎﻨﻴﺔ ﻟﻠﻁﺭﻕ ﻭﺍﻟﺨﺼـﺎﺌﺹ. ﺍﻟﻤﺯﻴـﺩ ﺍﻴﻀـﺎ، ﻴﻤﻜـﻥ‬
‫ﺍﺨﻔﺎﺀ ﺠﺯﺀ ﻤﻥ ﺍﻟﺸﻴﻔﺭﺍﺕ ﺍﻟﻤﺼﺩﺭﻴﺔ ﻭﺍﻅﻬﺎﺭﻩ ﺒﺎﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺭﻤﻭﺯ "+" ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﻴﺴﺎﺭ ﺍﻟﻨﺎﻓﺫﺓ.‬

‫ﺸﻜل 1 -01: ﻨﺎﻓﺫﺓ ﻤﺤﺭﺭ ﺍﻟﺸﻴﻔﺭﺓ.‬
‫02‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻴﻤﻜﻨﻙ ﺘﺨﺼﻴﺹ ﻭﺘﻐﻴﻴﺭ ﺍﻋﺩﺍﺩﺍﺕ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ )ﻜﺎﻟﺨﻁﻭﻁ، ﺍﻻﻟﻭﺍﻥ، ﺍﻟﻤﺤﺎﺫﺍﺓ ....ﺍﻟﺦ( ﺒﺎﻻﻨﺘﻘـﺎل ﺍﻟـﻰ ﺨﺎﻨـﺔ‬
‫ﺍﻟﺘﺒﻭﻴﺏ ‪ Text Editor‬ﻓﻲ ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ‪) Option‬ﺸﻜل 1 -4(.‬

‫اﻟﻘﺎﺋﻤﺔ اﻟﺮﺋﻴﺴﺔ‬
‫ﻓﻴﻤﺎ ﻴﻠﻲ ﻋﺭﺽ ﺴﺭﻴﻊ ﻟﻤﺤﺘﻭﻴﺎﺕ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﺭﺌﻴﺴﺔ ﺒﺸﻜل ﻤﺨﺘﺼﺭ.‬
‫ﺍﻟﻘﺎﺌﻤﺔ ‪:File‬‬
‫ﻤﻌﻅﻡ ﺍﻭﺍﻤﺭ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﺘﺘﻌﻠﻕ ﺒﻤﻠﻔﺎﺕ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ، ﺤﻴﺙ ﺘﻤﻜﻨـﻙ ﻤـﻥ ﺤﻔﻅﻬـﺎ، ﻓﺘﺤﻬـﺎ، ﺍﻏﻼﻗﻬـﺎ‬

‫ﻭﺍﻀﺎﻓﺔ ﻋﻨﺎﺼﺭ ﻭﻤﻠﻔﺎﺕ ﺍﺨﺭﻯ ﺍﻀﺎﻓﻴﺔ. ﻜﻤﺎ ﺍﻨﻙ ﺘﺴﺘﻁﻴﻊ ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﻭﻅﺎﺌﻑ ﺍﻟﻁﺒﺎﻋـﺔ ‪ Printing‬ﻋـﻥ‬
‫ﻁﺭﻴﻕ ﻫﺫﻩ ﺍﻟﻘﺎﺌﻤﺔ.‬
‫ﺍﻟﻘﺎﺌﻤﺔ ‪:Edit‬‬
‫ﻋﻤﻠﻴﺎﺕ ﺍﻟﺘﺤﺭﻴﺭ ﻜﺎﻟﻨﺴﺦ ‪ ،Copy‬ﺍﻟﻘﺹ ‪ ،Cut‬ﻭﺍﻟﻠﺼﻕ ‪ Paste‬ﻤﻭﺠﻭﺩﺓ ﻓﻲ ﻫﺫﻩ ﺍﻟﻘﺎﺌﻤﺔ، ﺒﺎﻻﻀـﺎﻓﺔ ﺍﻟـﻰ‬
‫ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﺩﻭﺍﺕ ﺍﻟﺒﺤﺙ ﻭﻋﻼﻤﺔ ﺍﻟﻤﻼﺤﻅﺎﺕ ‪.Bookmarks‬‬

‫ﺍﻟﻘﺎﺌﻤﺔ ‪:View‬‬
‫ﺘﺘﻌﻠﻕ ﺒﺎﻅﻬﺎﺭ ﻭﺍﺨﻔﺎﺀ ﻤﺠﻤﻭﻋﺔ ﻜﺒﻴﺭﺓ ﻤﻥ ﺍﻟﻨﻭﺍﻓﺫ ﻤﺘﻌﺩﺩﺓ ﺍﻟﻭﻅﺎﺌﻑ ﻭﺍﻻﻏﺭﺍﺽ.‬
‫ﺍﻟﻘﺎﺌﻤﺔ ‪:Project‬‬
‫ﺘﺘﻌﻠﻕ ﺒﺎﻟﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ ﺤﻴﺙ ﺘﻭﻓﺭ ﺍﻭﺍﻤﺭ ﻻﻀﺎﻓﺔ ﻋﻨﺎﺼﺭ ﻭﻤﻠﻔـﺎﺕ ﺍﺨـﺭﻯ ﻟﻠﻤﺸـﺭﻭﻉ، ﻜﻤـﺎ ﺘﺴـﺘﻁﻴﻊ‬
‫ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﻨﺎﻓﺫﺓ ﺍﻟﻤﺭﺍﺠﻊ ‪ Reference‬ﺍﻴﻀﺎ ﻤﻥ ﺨﻼل ﻫﺫﻩ ﺍﻟﻘﺎﺌﻤﺔ. ﺒﺎﻟﻨﺴﺒﺔ ﻟﻼﻤـﺭ ‪Set As Startup‬‬
‫‪ Project‬ﻓﻬﻭ ﻴﺠﻌل ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ ﻫﻭ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻻﺒﺘﺩﺍﺌﻲ، ﻭﺫﻟﻙ ﻓﻲ ﺤﺎﻟﺔ ﻭﺠﻭﺩ ﺍﻜﺜـﺭ ﻤـﻥ ﻤﺸـﺭﻭﻉ‬

‫‪ Project‬ﻓﻲ ﻨﻔﺱ ﺍﻟﺤل ‪.Solution‬‬
‫ﺍﻟﻘﺎﺌﻤﺔ ‪:Build‬‬

‫ﺘﻤﻜﻨﻙ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻤﻥ ﺘﺭﺠﻤﺔ ﺍﻟﻤﺸﺭﻭﻉ ‪ ،Compiling‬ﻭﺒﺎﻟﻨﺴـﺒﺔ ﻟﻼﻤـﺭ ‪Configuration Manager‬‬
‫ﻓﻬﻭ ﻴﺤﺩﺩ ﺍﻻﻋﺩﺍﺩﺍﺕ ﺍﻟﻤﺴﺒﻘﺔ ﺍﻟﺤﻔﻅ ﻟﻠﻤﺘﺭﺠﻡ.‬
‫ﺍﻟﻘﺎﺌﻤﺔ ‪:Debug‬‬
‫ﻟﺤﻅﺔ ﺘﺼﻤﻴﻡ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺘﻜﻭﻥ ﻋﺩﺩ ﻋﻨﺎﺼﺭ ﻫﺫﻩ ﺍﻟﻘﺎﺌﻤﺔ ﻻ ﺘﺘﺠﺎﻭﺯ 9 ﺍﻭﺍﻤﺭ، ﻭﻟﻜﻥ ﻋﻨﺩ ﺍﻟﺘﻨﻔﻴـﺫ ﺴـﻴﻤﺘﺩ ﻫـﺫﺍ‬

‫ﺍﻟﻌﺩﺩ ﻟﻴﺼل ﺍﻟﻰ 31 ﺍﻤﺭ )ﺒﻌﻀﻬﺎ ﻏﻴﺭ ﻤﻔﻌل(، ﺘﺠﺩ ﺍﻭﺍﻤﺭ ﺍﻟﺘﻨﻔﻴﺫ ﻭﺍﻻﻴﻘﺎﻑ ﺍﻟﻨﻬـﺎﺌﻲ ﻭﺍﻟﻤﺅﻗـﺕ ﻓـﻲ ﻫـﺫﻩ‬
‫ﺍﻟﻨﺎﻓﺫﺓ، ﻜﻤﺎ ﺘﺤﺘﻭﻱ ﻋﻠﻰ ﺠﻤﻴﻊ ﻭﻅﺎﺌﻑ ﺍﻟﺘﻨﻘﻴﺢ ‪ Debugging‬ﻟﻠﺒﺭﻨﺎﻤﺞ.‬
‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮف ﻋﻠﻰ ‪V isual Basic .NET‬‬
‫12‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫اﻧﻈﺮ اﻳﻀﺎ‬
‫ﻟﻌﺮض ﺑ ﻀﻌﺔ اواﻣﺮ ﻣﻦ هﺬﻩ اﻟﻘﺎﺋﻤـﺔ وادوات اﻟﺘﻨﻘـﻴﺢ، اﻧﺘﻘـﻞ اﻟـﻰ اﻟﻔ ﺼـﻞ‬
‫اﻟﺴﺎﺑﻊ اآﺘﺸﺎف اﻻﺧﻄﺎء.‬

‫ﺍﻟﻘﺎﺌﻤﺔ ‪:Tools‬‬
‫ﺘﺤﺘﻭﻱ ﻋﻠﻰ ﺍﻭﺍﻤﺭ ﺍﻀﺎﻓﻴﺔ ﻤﺨﺘﻠﻔﺔ ﺍﻟﻭﻅﺎﺌﻑ، ﻜﻤﺎ ﻴﻤﻜﻨﻙ ﺠﻌﻠﻬﺎ ﻤﻨﺼﺔ ﻟﺘﺸﻐﻴل ﺒـﺭﺍﻤﺞ ﺍﺨـﺭﻯ ﺘﺴـﺘﺨﺩﻤﻬﺎ‬

‫ﺒﺸﻜل ﻤﺘﻜﺭﺭ ﻋﻥ ﻁﺭﻴﻕ ﺍﺨﺘﻴﺎﺭ ﺍﻻﻤـﺭ ‪ .Externals Tools‬ﻭﺒﺎﻟﻨﺴـﺒﺔ ﻟﻼﻀـﺎﻓﺎﺕ ‪ ،Add-Ins‬ﻓـﻴﻤﻜﻥ‬
‫ﺍﻟﻭﺼﻭل ﻟﻬﺎ ﻋﻥ ﻁﺭﻴﻕ ﺍﺨﺘﻴﺎﺭ ﺍﻻﻤﺭ ‪.Add-In Manager‬‬
‫ﺍﻟﻘﺎﺌﻤﺔ ‪:Window‬‬
‫ﻻ ﺘﻌﻠﻴﻕ!‬
‫ﺍﻟﻘﺎﺌﻤﺔ ‪:Help‬‬
‫ﻻﺒﺩ ﻤﻥ ﺍﻥ ﺘﻜﻭﻥ ﻗﺩ ﺜﺒﺕ ﻨﺴﺨﺔ ﻤﻥ ﻤﻜﺘﺒـﺔ ‪ MSDN‬ﺍﻭ ‪ .NET Documentation‬ﺤﺘـﻰ ﺘـﺘﻤﻜﻥ ﻤـﻥ‬
‫ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ. ﻭﺒﺎﻟﻨﺴﺒﺔ ﻟﻼﻤﺭ ‪ ،Dynamic Help‬ﻓﻬﻭ ﻴﻌﺭﺽ ﻟﻙ ﻨﺎﻓﺫﺓ ﺘﻅﻬﺭ ﺘﻌﻠﻴﻤـﺎﺕ ﻓﻭﺭﻴـﺔ‬

‫ﺒﻤﺠﺭﺩ ﺍﻟﻨﻘﺭ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﻋﻠﻰ ﺍﻱ ﻋﻨﺼﺭ ﺍﻭ ﻨﺎﻓﺫﺓ ﻤﻥ ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ. ﺍﻨﺼﺤﻙ ﺒﺎﻏﻼﻕ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻋﻨـﺩ ﻋـﺩﻡ‬
‫ﺍﻟﺤﺎﺠﺔ ﺇﻟﻴﻬﺎ، ﻓﻬﻲ ﺘﺴﺒﺏ ﺒﻁﺀ ﻨﺴﺒﻲ ﻓﻲ ﺍﻟﺠﻬﺎﺯ ﺨﺎﺼﺔ ﺍﻥ ﻜﺎﻥ ﺠﻬﺎﺯﻙ ﺒﻁﻲﺀ.‬

‫اﺷﺮﻃﺔ اﻻدوات‬

‫ﺍﺸﺭﻁﺔ ﺍﻻﺩﻭﺍﺕ ‪ Toolbars‬ﻤﺎ ﻫﻲ ﺍﻻ ﺍﻭﺍﻤﺭ ﻤﺜل ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﺭﺌﻴﺴﻴﺔ ﺘﻘﺭﻴﺒﺎ، ﻴﻤﻜـﻥ ﺍﻀـﺎﻓﺘﻬﺎ‬

‫ﺘﺤﺭﻴﺭﻫﺎ ﻭﺤﺫﻓﻬﺎ ﺒﺎﻟﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻻﻴﻤﻥ ﻋﻠﻰ ﺍﻱ ﺸﺭﻴﻁ ﻭﺍﺨﺘﻴﺎﺭ ﺍﻻﻤـﺭ ‪ Customize‬ﻤـﻥ ﺍﻟﻘﺎﺌﻤـﺔ‬
‫ﺍﻟﻤﻨﺒﺜﻘﺔ، ﺘﻤﺎﻤﺎ ﻜﻤﺎ ﺘﻔﻌل ﻤﻊ ﻁﺎﻗﻡ ﺘﻁﺒﻴﻘﺎﺕ ‪.Microsoft Office‬‬
‫ﹰ‬

‫آﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺠﻚ اﻻول‬

‫ﻭﺍﻻﻥ ﺴﻨﺒﺩﺃ ﺒﻜﺘﺎﺒﺔ ﺍﻭل ﺒﺭﻨﺎﻤﺞ ﻟﻙ ﺒﻠﻐﺔ ‪ Visual Basic .NET‬ﺤﺘﻰ ﺘﺘﻤﻜﻥ ﻤﻥ ﺍﺴـﺘﺨﺩﺍﻡ ﺒﻴﺌـﺔ ‪Visual‬‬
‫‪ Studio .NET‬ﺒﺸﻜل ﻤﺒﺩﺌﻲ.‬

‫اﻟﺤﻠﻮل واﻟﻤﺸﺎرﻳﻊ‬
‫ﺍﻟﺤل ‪ Solution‬ﻫﻭ ﻋﺒﺎﺭﺓ ﻋﻥ ﺤﺎﻭﻴﺔ ﻟﻌﻨﺼـﺭ ﺍﻭ ﻤﺠﻤﻭﻋـﺔ ﻋﻨﺎﺼـﺭ ﺘﺴـﻤﻰ ﺍﻟﻤﺸـﺎﺭﻴﻊ ‪،Projects‬‬

‫ﻭﺍﻟﻤﺸﺭﻭﻉ ﻫﻭ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺫﻱ ﺘﻭﺩ ﺍﻨﺸﺎﺌﻪ ﻭﺍﻟﺫﻱ ﺒﺩﻭﺭﻩ ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﻋﺩﺓ ﻋﻨﺎﺼﺭ ﺘﺴـﻤﻰ ﻤﻠﻔـﺎﺕ ﺍﻟﻤﺸـﺭﻭﻉ‬
‫‪ Project Files‬ﺍﻭ ﻭﺤﺩﺍﺕ ﺍﻟﻤﺸﺭﻭﻉ ‪.Project Items‬‬
‫22‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺴﺄﺒﺩﺃ ﻤﻌﻙ ﺒﺎﻟﺤل ‪ ،Solution‬ﻴﻤﻜﻨﻙ ﺍﻨﺸﺎﺀ ﺤل ﺠﺩﻴﺩ ﺒﺎﺨﺘﻴﺎﺭ ﺍﻻﻤـﺭ ﺍﻟﻔﺭﻋـﻲ ‪Blank Solution‬‬
‫ﻤﻥ ﺍﻻﻤﺭ ‪ New‬ﻤﻥ ﻗﺎﺌﻤﺔ ‪ File‬ﺤﻴﺙ ﺴﻴﻅﻬﺭ ﻟﻙ ﺼﻨﺩﻭﻕ ﺤﻭﺍﺭ ﺒﻌﻨـﻭﺍﻥ ‪ New Project‬ﻴﻁﻠـﺏ ﻤﻨـﻙ‬

‫ﺍﺴﻡ ﺍﻟﺤل ﻭﻤﺴﺎﺭ ﻤﺠﻠﺩﻩ. ﺒﻌﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ‪ OK‬ﺴﺘﻨﺸﺊ ﻟﻙ ﺒﻴﺌـﺔ ﺍﻟﺘﻁـﻭﻴﺭ ‪Visual Studio .NET‬‬
‫ﻤﻠﻔﻴﻥ -ﻓﻲ ﻨﻔﺱ ﺍﻟﻤﺠﻠﺩ ﺍﻟﺫﻱ ﺤﺩﺩﺘﻪ ﺴﺎﺒﻘﺎ - ﺒﺎﻻﻤﺘﺩﺍﺩﻴﻥ ‪ .sln‬ﻭ ‪ .suo‬ﺍﻟﻤﻠﻑ ‪ sln‬ﻫﻭ ﻤﻠـﻑ ﻨﺼـﻲ ﻴﻤﺜـل‬
‫ﹰ‬
‫ﻤﺭﺍﺠﻊ ﺍﻟﻰ ﺍﻟﻤﺸﺎﺭﻴﻊ ﺍﻟﻤﻀﻤﻨﺔ ﻓﻲ ﺍﻟﺤل ﺍﻟﺤﺎﻟﻲ، ﺍﻤﺎ ﺍﻟﻤﻠﻑ ‪ suo‬ﻓﻴﺤﺘـﻭﻱ ﻋﻠـﻰ ﺍﻻﻋـﺩﺍﺩﺍﺕ ﻭﺨﻴـﺎﺭﺍﺕ‬

‫ﺍﻟﺘﺨﺼﻴﺹ ﺍﻟﺘﻲ ﺘﺤﺩﺩﻫﺎ ﻓﻲ ﻫﺫﺍ ﺍﻟﺤل ﻜﻤﻭﺍﻗﻊ ﺍﻟﻨﻭﺍﻓﺫ ﺍﻟﻤﻔﺘﻭﺤﺔ ﻭﻏﻴﺭﻫﺎ.‬

‫ﺒﻌﺩ ﺍﻨﺸﺎﺌﻙ ﺤل ﺠﺩﻴﺩ ﻗﺩ ﺘﺒﺩﺃ ﺒﺎﻀﺎﻓﺔ ﻤﺸﺭﻭﻉ ﺍﻭ ﻋﺩﺓ ﻤﺸﺎﺭﻴﻊ ﺍﻟﻴﻪ، ﺍﺨﺘﺭ ﺍﻻﻤـﺭ ﺍﻟﻔﺭﻋـﻲ ‪Project‬‬

‫ﻤﻥ ﺍﻻﻤﺭ ‪ New‬ﻤﻥ ﻗﺎﺌﻤﺔ ‪ File‬ﺴﻴﻅﻬﺭ ﻟﻙ ﻨﻔﺱ ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﺍﻟﺴﺎﺒﻕ، ﺍﻨﻘـﺭ ﻋﻠـﻰ ﺍﻟﻌﻨﺼـﺭ ‪Node‬‬
‫ﻓﻲ ﺍﻟﺸﺠﺭﺓ ﺍﻟﻴﺴﺭﻯ ﺍﻟﺫﻱ ﻴﺤﻤل ﺍﻻﺴﻡ ‪ Visual Basic Projects‬ﺤﺘﻰ ﺘﻅﻬﺭ ﻟﻙ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻴﻤﻨﻰ ﻋـﺩﺓ‬
‫ﻗﻭﺍﻟﺏ ‪ Templates‬ﺠﺎﻫﺯﺓ ﻟﻼﺴﺘﺨﺩﺍﻡ. ﺤﺩﺩ ﻨﻭﻉ، ﺍﺴﻡ، ﻭﻤﺴﺎﺭ ﺍﻟﻤﺸﺭﻭﻉ ﺜﻡ ﺘﺄﻜﺩ ﻤـﻥ ﺍﻻﺨﺘﻴـﺎﺭ ‪Add to‬‬

‫‪ solution‬ﻗﺒل ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ‪) OK‬ﺸﻜل 1 -11(:‬

‫ﺸﻜل 1 -11: ﺍﻟﻘﻭﺍﻟﺏ ‪ Templates‬ﺍﻟﺠﺎﻫﺯﺓ ﻭﺍﻟﺘﻲ ﺘﻤﺜل ﻤﺸﺎﺭﻴﻊ ﻴﻤﻜﻨﻙ ﺍﻟﺒﺩﺀ ﻓﻴﻬﺎ.‬
‫ﻴﻤﻜﻨﻙ ﺍﻀﺎﻓﺔ ﺍﻟﻤﺯﻴﺩ ﻤﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ ﺒﻤﺨﺘﻠﻑ ﺍﻨﻭﺍﻋﻬﺎ، ﻭﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﻅﺭﻴﻔﺔ ﺍﻟﺘﻲ ﺘﻤﻜﻨﻙ ﻤـﻥ ﺍﻟﺘﺤﻭﻴـل‬
‫ﺒﻴﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ ﻫﻲ ﻨﺎﻓﺫﺓ ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤﺎل ‪) Solution Explorer‬ﺸﻜل 1 -6(.‬

‫ﺒﺎﻟﻨﺴﺒﺔ ﻟﻤﻠﻔﺎﺕ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﻤﻨﺠﺯﺓ ﺒﻠﻐﺔ ‪ Visual Basic .NET‬ﻓﺠﻤﻴﻌﻬـﺎ ﺘﻨﺘﻬـﻲ ﺒﺎﻻﻤﺘـﺩﺍﺩ ‪.vb‬‬

‫ﻤﻬﻤﺎ ﻜﺎﻥ ﻨﻭﻋﻬﺎ )ﺴﻭﺍﺀ ﻤﻠﻔﺎﺕ ﺍﺩﻭﺍﺕ ﺍﻟـﺘﺤﻜﻡ ‪ ،UserControls‬ﻨﻤـﺎﺫﺝ ‪ ،Windows Forms‬ﺍﻟﻔﺌـﺎﺕ‬
‫‪... Classes‬ﺍﻟﺦ(، ﻭﻓﻲ ﺍﻟﺤﻘﻴﻘﺔ ﻴﻤﻜﻥ ﻟﻠﻤﻠﻑ ﺍﻟﻭﺍﺤﺩ ﺍﻥ ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﺠﻤﻴﻊ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺴﺎﺒﻘﺔ.‬
‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮف ﻋﻠﻰ ‪V isual Basic .NET‬‬
‫32‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫اﻧﻮاع اﻟﻤﺸﺎرﻳﻊ‬
‫ﻴﻤﻜﻨﻙ ‪ Visual Basic .NET‬ﻤﻥ ﺩﻤﺞ ﻋﺩﺓ ﺍﻨﻭﺍﻉ ﻤﺨﺘﻠﻔـﺔ ﻤـﻥ ﺍﻟﻤﺸـﺎﺭﻴﻊ ﻜـﺎﺩﻭﺍﺕ ﺍﻟـﺘﺤﻜﻡ ‪User‬‬
‫‪ ،Controls‬ﺘﻁﺒﻴﻘﺎﺕ ﻗﻴﺎﺴﻴﺔ ‪ ،Windows Application‬ﻤﻜﺘﺒﺎﺕ ﺍﻟﻔﺌـﺎﺕ ‪ Class Library‬ﻭﻏﻴﺭﻫـﺎ،‬
‫ﺭﺒﻤﺎ ﺘﻜﻭﻥ ﻗﺩ ﻻﺤﻅﺘﻬﺎ ﻓﻲ ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﺍﻟﺴﺎﺒﻕ ‪ ،New Projects‬ﻭﺍﻟﻴﻙ ﻴﺎ ﻗـﺎﺭﺌﻲ ﺍﻟﻌﺯﻴـﺯ ﻤﻠﺨـﺹ‬

‫ﻋﻨﻬﺎ:‬
‫‪:Windows Application‬‬

‫ﻭﻫﻲ ﻤﺸﺎﺭﻴﻊ ﺘﺸﺎﺒﻪ ﺘﻁﺒﻴﻘﺎﺕ ‪ Windows‬ﺍﻟﻘﻴﺎﺴـﻴﺔ ) ﺍﻱ ‪ .(Standard Application‬ﺍﻟﺠـﺯﺀ ﺍﻟﺜﺎﻟـﺙ‬
‫ﺘﻁﻭﻴﺭ ﺘﻁﺒﻴﻘﺎﺕ ‪ Windows‬ﻤﺨﺼﺹ ﻟﻬﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ.‬
‫‪:Class Library‬‬
‫ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﻤﻜﺘﺒﺔ ﻓﺌﺎﺕ ﻴﻤﻜﻨﻙ ﺍﻻﺴﺘﻔﺎﺩﺓ ﻤﻨﻬﺎ ﻓﻲ ﺒـﺭﺍﻤﺞ ﺍﺨـﺭﻯ، ﻜﻤـﺎ ﻴﻤﻜﻨـﻙ‬

‫ﺘﺭﺠﻤﺘﻬﺎ ﺍﻟﻰ ﻤﻠﻔﺎﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ DLL‬ﺍﻭ ﺤﺘﻰ ‪ EXE‬ﺍﻥ ﺍﺭﺩﺕ.‬
‫‪:Windows Control Library‬‬

‫ﻴﻤﻜﻨﻙ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ ﻤـﻥ ﺍﻨﺸـﺎﺀ ﺍﺩﻭﺍﺕ ﺘﺤﻜـﻡ ‪ User Controls‬ﺘﺴـﺘﺨﺩﻤﻬﺎ ﻓـﻲ ﺘﻁﺒﻴﻘـﺎﺕ‬
‫‪ .Windows Application‬ﺴﻨﻁﺒﻕ ﺍﺩﻭﺍﺕ ﺍﻟﺘﺤﻜﻡ ﺒﻌﺩ ﻤﺌﺎﺕ ﺍﻟﺼﻔﺤﺎﺕ ﺍﻟﻰ ﺍﻥ ﻨﺼل ﻟﻠﻔﺼـل ﺍﻟﺴـﺎﺩﺱ‬

‫ﻋﺸﺭ ﻤ ﻭﺍﻀﻴﻊ ﻤﺘﻘﺩﻤﺔ.‬

‫‪:ASP .NET Web Application‬‬

‫ﻴﻤﻜﻨﻙ ﻤﻥ ﺍﻨﺸﺎﺀ ﻤﺸﺎﺭﻴﻊ ‪ ASP .NET‬ﺒﺤﻴﺙ ﺘﻌﻤل ﻓﻲ ﺠﻬﺔ ﺍﻟﺨﺎﺩﻡ ‪ Server‬ﻭﻴﺘﻡ ﻋﺭﺽ ﺼﻔﺤﺎﺘﻬﺎ ﻋـﻥ‬
‫ﻁﺭﻴﻕ ﻋﻤﻼﺀ ‪ Clients‬ﺒﺎﺤـﺩ ﺍﻟﻤﺘﺼـﻔﺤﺎﺕ ‪ .Browsers‬ﺍﻟﻔﺼـﻼﻥ ﺍﻟﻌﺸـﺭﻭﻥ ﻭﺍﻟﺤـﺎﺩﻱ ﻭﺍﻟﻌﺸـﺭﻭﻥ‬
‫ﺘﻁﺒﻴﻘﺎﺕ ‪ ASP .NET‬ﻤﺨﺼﺹ ﻟﻬﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ.‬

‫‪:ASP .NET Web Service‬‬

‫ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ ﻴﺴﻬل ﻋﻠﻴـﻙ ﻋﻤﻠﻴـﺔ ﺘﺒـﺎﺩل ﺍﻟﺒﻴﺎﻨـﺎﺕ ﻋﺒـﺭ ﺍﻻﻨﺘﺭﻨـﺕ ﻋـﻥ ﻁﺭﻴـﻕ ﺍﺴـﺘﺨﺩﺍﻡ‬

‫ﺒﺭﻭﺘﻭﻜﻭﻻﺕ ‪ TCP/IP‬ﻭ ‪ XML‬ﺍﻟﻘﻴﺎﺴﻴﺔ ﺩﻭﻥ ﺍﻟﺤﺎﺠﺔ ﺍﻟﻰ ﺘﻁﻭﻴﺭ ﺍﻟﻤﻜﻭﻨﺎﺕ ﺍﻟﻤﻭﺯﻋـﺔ ‪– DCOM‬ﻜﻤـﺎ‬
‫ﺴﺘﺭﻯ ﻻﺤﻘﺎ ﻓﻲ ﺍﻟﻔﺼل ﺍﻟﺜﺎﻨﻲ ﻭﺍﻟﻌﺸﺭﻭﻥ ﺨﺩﻤﺎﺕ ﻭﻴﺏ ‪.Web Services‬‬
‫‪:Web Control Library‬‬

‫ﻴﻤﻜﻨﻙ ﺘﻁﻭﻴﺭ ﻤﺸﺎﺭﻴﻊ ﺸﺒﻴﻬﺔ ﺒﺎﺩﻭﺍﺕ ﺍﻟﺘﺤﻜﻡ ﻟﻜﻨﻬﺎ ﺨﺎﺼـﺔ ﻟﻠﻌـﺭﺽ ﻋﻠـﻰ ﺼـﻔﺤﺎﺕ ‪ ،HTML‬ﻭﻫـﻲ‬
‫ﻤﺸﺎﺒﻬﺔ ﺍﻟﻰ ﺤﺩ ﻜﺒﻴﺭ ﺒﻤﺸـﺎﺭﻴﻊ ﺍﺩﻭﺍﺕ ﺍﻟـﺘﺤﻜﻡ ‪ ،User Controls‬ﻭﻟﻜﻨﻬـﺎ ﺘﻌـﺭﺽ ﻓـﻲ ﺍﻟﻤﺴـﺘﻌﺭﺽ‬

‫‪.Browser‬‬
‫42‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫‪:Console Application‬‬
‫ﺍﺫﺍ ﻜﻨﺕ ﺘﺸﻌﺭ ﺒﺎﻟﺤﻨﻴﻥ ﺍﻟﻰ ﺘﻁﻭﻴﺭ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﺘﺤﺕ ﺒﻴﺌﺔ ‪ DOS‬ﻓﻬﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻤﻨﺎﺴـﺏ ﻟـﻙ ﺘﻤﺎﻤـﺎ. ﺒﺎﻟﻨﺴـﺒﺔ‬
‫ﹰ‬
‫ﻟﻨﺎ، ﺴﻨﺴﺘﻤﺭ ﻓﻲ ﺘﻁﻭﻴﺭ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ ﺤﺘﻰ ﻨﻬﺎﻴﺔ ﺍﻟﺠﺯﺀ ﺍﻟﺜﺎﻨﻲ ﻤﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ.‬
‫‪:Windows Services‬‬

‫ﻨﻭﻉ ﺨﺎﺹ ﻤﻥ ﺘﻁﺒﻴﻘﺎﺕ ‪ Windows‬ﺍﻟﻘﻴﺎﺴﻴﺔ ﺒﺤﻴﺙ ﻴﻌﻤل ﻓﻲ ﺍﻟﺨﻠﻔﻴﺔ ‪ Background‬ﺩﺍﺌﻤـﺎ ﻤﻨـﺫ ﺒﺩﺍﻴـﺔ‬
‫ﺘﺤﻤﻴل ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ﺤﺘﻰ ﺍﻏﻼﻕ ﺠﻬﺎﺯ ﺍﻟﻜﻤﺒﻴﻭﺘﺭ. ﻟﻲ ﻋﻭﺩﺓ ﺍﻟﻰ ﻫـﺫﺍ ﺍﻟﻤﻭﻀـﻭﻉ ﻓـﻲ ﺍﻟﻔﺼـل ﺍﻟﺴـﺎﺩﺱ‬
‫ﻋﺸﺭ ﻤﻭﺍﻀﻴﻊ ﻤﺘﻘﺩﻤﺔ.‬

‫‪:Empty Project‬‬

‫ﺴﻬﻠﺔ ﺠﺩﺍ ﻭﻻ ﺘﺤﺘﺎﺝ ﺍﻟﻰ ﺘﻔﺎﺼﻴل.‬

‫‪:Empty Web Project‬‬
‫ﺍﺴﻬل ﻤﻥ ﺴﺎﺒﻘﺘﻬﺎ.‬
‫ﺒﻌﺩ ﻫﺫﻩ ﺍﻟﺠﻭﻟﺔ ﺍﻟﺴﺭﻴﻌﺔ ﺤﻭل ﺍﻨﻭﺍﻉ ﺍﻟﻤﺸﺎﺭﻴﻊ، ﻴﺅﺴﻔﻨﻲ ﺍﺨﺒﺎﺭﻙ ﺒﺎﻥ ﻤﺎ ﺫﻜﺭﻨﺎﻩ ﻫـﻭ ﻤﺠـﺭﺩ ﻗﻭﺍﻟـﺏ‬
‫‪ Templates‬ﺘﻘﻭﻡ ﺒﺘﻭﻟﻴﺩ ﺍﻟﺸﻴﻔﺭﺍﺕ ﺍﻟﻀﺭﻭﺭﻴﺔ ﻟﻌﻤل ﻤﺎ ﺘﺭﻴﺩ، ﺒل ﺤﺘﻰ ﻴﻤﻜﻨﻙ ﺍﻨﺸـﺎﺀ ﺍﻟﻤﺯﻴـﺩ ﻤـﻥ ﻫـﺫﻩ‬

‫ﺍﻟﻘﻭﺍﻟﺏ ﺍﻭ ﺤﺫﻑ ﺍﻟﺤﺎﻟﻴﺔ، ﻓﺎﻟﺤل ﺍﻟﻭﺍﺤـﺩ ﻗـﺩ ﻴﺸـﻤل ﺨﺩﻤـﺔ ‪ Windows Service‬ﻭ ﺒﺭﻨـﺎﻤﺞ ﻗﻴﺎﺴـﻲ‬
‫‪ Windows Application‬ﻭ ﺍﺩﺍﺓ ﺘﺤﻜﻡ ‪ ،User Control‬ﺍﻟﺴﺭ ﻜﻠـﻪ ﻴﻜﻤـﻥ ﻓـﻲ ﺸـﻴﻔﺭﺍﺕ ﻤﻠﻔـﺎﺕ‬

‫ﺍﻟﻤﺸﺭﻭﻉ.‬

‫ﺑﻨﺎء ﺑﺮﻧﺎﻣﺠﻚ اﻻول‬

‫ﻜل ﺍﻟﻁﺭﻕ ﺘﺅﺩﻱ ﺍﻟﻰ ﺭﻭﻤﺎ ﻫﻲ ﻤﻘﻭﻟﺔ ﻗﺩﻴﻤﺔ، ﻟﺩﻴﻙ ﻋﺸﺭﺍﺕ ﺍﻟﻁﺭﻕ ﻭﺍﻟﻭﺴﺎﺌل ﺍﻟﺘـﻲ ﺘﻤﻜﻨـﻙ ﻤـﻥ ﻜﺘﺎﺒـﺔ‬

‫ﺒﺭﻨﺎﻤﺠﻙ ﺍﻻﻭل ﺒـ ‪ Visual Basic .NET‬ﺍﺒﺘﺩﺍﺀ ﻤﻥ ﻤﻠﻔﺎﺕ ﻨﺼـﻴﺔ ﺒﺎﺴـﺘﺨﺩﺍﻡ ﺍﻟﻤﻔﻜـﺭﺓ ‪ Notepad‬ﺍﻭ‬
‫ﺤﺘﻰ ﺍﺴﺘﺨﺩﺍﻡ ﺍﺤﺩ ﺍﻟﻘﻭﺍﻟﺏ ﺍﻟﺠﺎﻫﺯﺓ -ﻜﻘﺎﻟﺏ ‪.Console Application‬‬

‫ﻤﺎ ﻴﻬﻤﻨﻲ ﻓﻲ ﻫﺫﺍ ﺍﻟﻔﺼل ﺍﻋﻁﺎﺌﻙ ﺍﻟﺨﻁﻭﺍﺕ ﺍﻻﺴﺎﺴﻴﺔ ﻟﺒﻨـﺎﺀ ﺒﺭﺍﻤﺠـﻙ ﺍﻷﻭل ﺒــﺎﺴﺘﺨﺩﺍﻡ ‪Visual‬‬

‫‪ Basic .NET‬ﻭﻟﻴﺱ ﺍﻟﺒﺩﺀ ﺍﻟﻔﻌﻠﻲ ﺒﺸﺭﺡ ﻗﻭﺍﻋﺩ ﻭﻤﻔﺭﺩﺍﺕ ﺍﻟﻠﻐﺔ، ﻓﻠﻥ ﺍﻗﺩﻡ ﻟﻙ ﺍﻟﻜﺜﻴﺭ ﻤـﻥ ﺍﻟﺘﻔﺎﺼـﻴل، ﻤـﺎ‬

‫ﺍﻨﺸﺩﻩ ﻫﻨﺎ ﻫﻭ ﺘﻭﻀﻴﺢ ﻋﻤﻠﻴﺔ ﺒﻨﺎﺀ ﺍﻟﻤﺸﺎﺭﻴﻊ ﻭﺘﻨﻔﻴﺫﻫﺎ ﻓﻘﻁ.‬

‫ﺍﻨﺸﺊ ﺍﻱ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ﻭﻟﻨﻘل ‪ Console Application‬ﻋﻠﻰ ﺴﺒﻴل ﺍﻟﻤﺜـﺎل ﻓﻘـﻁ، ﺴـﺘﻼﺤﻅﺔ ﺍﻥ‬

‫ﻨﺎﻓﺫﺓ ﻤﺤﺭﺭ ﺍﻟﺸﻴﻔﺭﺓ ﻗﺩ ﻓﺘﺤﺕ ﻭﻜﺘﺏ ﺒﻬﺎ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ:‬

‫1‪Module Module‬‬
‫)(‪Sub Main‬‬
‫‪End Sub‬‬
‫‪End Module‬‬
‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮف ﻋﻠﻰ ‪V isual Basic .NET‬‬
‫52‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻏﻴﺭ ﺍﺴﻡ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ 1‪ Module‬ﺇﻟﻰ ‪ ،FirstProg‬ﺍﺴﺘﺨﺩﻡ ﺍﻟﻜﺎﺌﻥ ‪ Console‬ﻟﻌـﺭﺽ ﺍﻟﻤﺨﺭﺠـﺎﺕ‬
‫ﻋﻠﻰ ﺍﻟﺸﺎﺸﺔ. ﻫﺫﺍ ﺒﺭﻨﺎﻤﺠﻙ ﺍﻻﻭل ﻭﻫﻭ ﻴﻘﻭﻡ ﺒﻌﺭﺽ ﺍﻟﺒﺴﻤﻠﺔ ﻟﺘﻜﻭﻥ ﻓﺎﺘﺤﺔ ﺨﻴﺭ ﻋﻠﻴﻨﺎ ﺒﻤﺸﻴﺌﺔ ﺍﷲ:‬
‫‪Module FirstProg‬‬
‫)(‪Sub Main‬‬

‫)" ‪Cons ole.W riteL ine(" In th e nam e of Allah the most graci ous a nd th e mos t mer ciful‬‬

‫‪End Sub‬‬
‫‪End Module‬‬

‫ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﻤﻔﺘﺎﺡ ]5‪ [ F‬ﺍﻭ ﺍﺨﺘﺭ ﺍﻻﻤﺭ ‪ Start‬ﻤﻥ ﻗﺎﺌﻤﺔ ‪ Debug‬ﻟﺘﻨﻔﻴﺫ ﺍﻟﻤﺸﺭﻭﻉ، )ﻤﻊ ﺍﻟﻌﻠﻡ ﺍﻥ ﻋﻤﻠﻴـﺔ‬
‫ﺍﻟﺘﻨﻔﻴﺫ ﺘﺅﺩﻱ ﺍﻟﻰ ﻋﻤﻠﻴﺔ ﺍﻟﺘﺭﺠﻤﺔ ‪ Compiling‬ﺒﺸﻜل ﺘﻠﻘﺎﺌﻲ( ﺴﺘﻼﺤﻅ ﺍﻥ ﻨﺎﻓﺫﺓ ﺴـﻭﺩﺍﺀ ﻅﻬـﺭﺕ ﻭﺍﺨﺘﻔـﺕ‬

‫ﺒﺴﺭﻋﺔ، ﻭﻟﻜﻲ ﺘﺘﻤﻜﻥ ﻤﻥ ﺍﻴﻘﺎﻓﻬﺎ ﺍﻀﻑ ﺍﻻﻤﺭ ﺍﻟﺘﺎﻟﻲ ﻓـﻲ ﺍﻟﺒﺭﻨـﺎﻤﺞ ﺍﻟﺴـﺎﺒﻕ، ﺒﺤﻴـﺙ ﻴﺴـﻤﺢ ﻟﻠﻤﺴـﺘﺨﺩﻡ‬
‫ﺒﺎﻟﻀﻐﻁ ﻋﻠﻰ ﻤﻔﺘﺎﺡ ] ‪ [ ENTER‬ﻗﺒل ﺍﺨﻔﺎﺀ ﺍﻟﻨﺎﻓﺫﺓ:‬
‫‪Module FirstProg‬‬
‫)(‪Sub Main‬‬
‫…‬

‫)(‪Console.Read‬‬
‫‪End Sub‬‬
‫‪End Module‬‬

‫ﺍﻋﺩ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻟﺘﺭﻯ ﻤﺨﺭﺠﺎﺘﻪ )ﺸﻜل 1 -21(.‬

‫ﺸﻜل 1 -21: ﻤﺨﺭﺠﺎﺕ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻻﻭل.‬

‫اﺳﺘﺨﺪام ‪ArabicConsole‬‬
‫ﺍﻀﻁﺭﺭﺕ ﻓﻲ ﺍﻟﻔﻘﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ ﻻﺴﺘﺨﺩﺍﻡ ﺍﻟﻠﻐﺔ ﺍﻻﻨﺠﻠﻴﺯﻴﺔ ﻟﻌـﺭﺽ ﻤﺨﺭﺠـﺎﺕ ﺍﻟﺒﺭﻨـﺎﻤﺞ ﺍﻻﻭل ﻭﺫﻟـﻙ ﻻﻥ‬

‫ﺍﻟﻜﺎﺌﻥ ‪ Console‬ﻻ ﻴﺩﻋﻡ ﺍﻟﺤﺭﻭﻑ ﺍﻟﻌﺭﺒﻴﺔ، ﻭﺒﻤﺎ ﺍﻨﻲ ﺴﺎﻋﺘﻤﺩ ﻋﻠﻰ ﻫـﺫﺍ ﺍﻟﻜـﺎﺌﻥ ﻓـﻲ ﺸـﺭﺡ ﺍﻟﺸـﻴﻔﺭﺍﺕ‬
‫ﺍﻟﻤﺼﺩﺭﻴﺔ ﻓﻼﺒﺩ ﻤﻥ ﺍﺴﺘﺨﺩﺍﻤﻪ، ﻭﺒﺩﻻ ﻤﻥ ﺠﻌل ﺍﻤﺜﻠﺔ ﺍﻟﻜﺘﺎﺏ ﺘﻌﺘﻤـﺩ ﻋﻠـﻰ ﺍﻟﻜﻠﻤـﺎﺕ ﺍﻻﻨﺠﻠﻴﺯﻴـﺔ، ﻓﻜـﺭﺕ‬

‫ﺒﺘﻁﻭﻴﺭ ﻜﺎﺌﻥ ﻴﺤﻤل ﺍﻻﺴﻡ ‪ ArabicConsole‬ﻴﺤﺎﻜﻲ ﺍﻟﻜﺎﺌﻥ ‪ Console‬ﻴﻤﻜﻨـﻙ ﻤـﻥ ﺍﺴـﺘﺨﺩﺍﻡ ﺍﻟﺤـﺭﻭﻑ‬
‫ﺍﻟﻌﺭﺒﻴﺔ. ﻀﻊ ﻓﻲ ﺍﻻﻋﺘﺒﺎﺭ، ﺍﻥ ﺍﻟﻜـﺎﺌﻥ ‪ ArabicConsole‬ﻻ ﻴﺤﺘـﻭﻱ ﺍﻻ ﻋﻠـﻰ ﻁﺭﻴﻘـﺔ ﻭﺍﺤـﺩﺓ ﻫـﻲ‬
‫62‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫)(‪ WriteLine‬ﻓﻘﻁ، ﻭﻫﻲ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﻭﺤﻴﺩﺓ ﺍﻟﺘﻲ ﻨﺤﺘﺎﺠﻬﺎ ﻟﻌﺭﺽ ﺍﻟﻤﺨﺭﺠﺎﺕ. ﺍﻥ ﻜﻨﺕ ﺘﻭﺩ ﺍﺴـﺘﺨﺩﺍﻡ ﻫـﺫﺍ‬
‫ﺍﻟﻜﺎﺌﻥ ﻓﻲ ﻤﺸﺎﺭﻴﻌﻙ، ﻓﻴﻤﻜﻥ ﺍﻀﺎﻓﺘﻪ ﻋﻥ ﻁﺭﻴﻕ ﻨﺎﻓﺫﺓ ﺍﻟﻤﺭﺍﺠـﻊ )ﺸـﻜل 1 -7( ﻭﺍﻟﻀـﻐﻁ ﻋﻠـﻰ ﺍﻟـﺯﺭ‬
‫‪ Brows‬ﻭﻤﻥ ﺜﻡ ﺍﻟﺒﺤﺙ ﻋﻥ ﺍﻟﻤﻠﻑ ‪ ArabicConsole.DLL‬ﻓﻲ ﺍﻟﺩﻟﻴل ﺍﻟﺠﺫﺭﻱ ﻟﻠﻘﺭﺹ ﺍﻟﻤﺩﻤﺞ.‬

‫ﺒﻌﺩ ﺍﻀﺎﻓﺘﻙ ﻟﻤﺭﺠﻊ ﺍﻟﻜﺎﺌﻥ ‪ ArabicConsole‬ﻓﻲ ﻤﺸﺭﻭﻋﻙ، ﺘﺴﺘﻁﻴﻊ ﺍﺴﺘﺨﺩﺍﻤﺔ ﻤﺒﺎﺸـﺭﺓ ﻭﺘﻜﺘـﺏ‬
‫ﺸﻴﺌﺎ ﻤﺜل:‬
‫اﺿﻒ هﺬا اﻟﺴﻄﺮ ﻗﺒﻞ اﺳﺘﺨﺪ ام اﻟ ﻜﺎﺋ ﻦ '‬
‫‪' ArabicConsole‬‬
‫‪Imports ArabicConsoleProject‬‬

‫)"ﺑﺴﻢ اﷲ اﻟ ﺮﲪﻦ ا ﻟﺮﺣﻴ ﻢ"(‬

‫‪Module FirstProg‬‬
‫)(‪Sub Main‬‬
‫‪ArabicConsole.WriteLine‬‬
‫‪End Sub‬‬
‫‪End Module‬‬

‫اﻧﻈﺮ اﻳﻀﺎ‬
‫ﺳﺘﻔﻬﻢ اﻟﻐﺮض ﻣﻦ اﺳـﺘﺨﺪام اﻟﻌﺒـﺎرة ‪Imports A rabicConsoleProject‬‬
‫ﻓﻲ اﻟﻔ ﺼﻞ اﻟﺘﺎﻟﻲ ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ ﺑﻤﺸﻴﺌﺔ اﷲ.‬

‫ﻟﺴﺕ ﺒﺤﺎﺠﺔ ﻻﺴﺘﺨﺩﺍﻡ ﺍﻟﻁﺭﻴﻘﺔ )(‪ Read‬ﺤﺘﻰ ﺘﻤﻨﻊ ﺍﻟﻨﺎﻓﺫﺓ ﻤﻥ ﺍﻻﻏﻼﻕ ﺍﻟﺘﻠﻘـﺎﺌﻲ، ﺤﻴـﺙ ﺍﻥ ﺍﻟﻜـﺎﺌﻥ‬
‫‪ ArabicConsole‬ﻴﻌﻁﻴﻙ ﻓﺭﺼﺔ ﺍﻏﻼﻗﻬﺎ ﺒﻨﻔﺴﻙ.‬

‫اﻟﺘﺮﺟﻤﺔ واﻟﺘﻮزﻳﻊ‬
‫ﺍﻟﻨﻘﻁﺔ ﺍﻻﺨﻴﺭﺓ ﺍﻟﺘﻲ ﺍﺭﻴﺩ ﺍﻟﺘﻁﺭﻕ ﻟﻬﺎ ﻫﻲ ﻋﻤﻠﻴـﺔ ﺘﺭﺠﻤـﺔ ﺍﻟﺒﺭﻨـﺎﻤﺞ ‪ Compiling‬ﻭﺘﻭﺯﻴﻌـﻪ، ﺒﺎﻟﻨﺴـﺒﺔ‬
‫ﻟﻠﺘﺭﺠﻤﺔ ﻓﺘﻭﺠﺩ ﻋﺸﺭﺍﺕ ﺍﻟﺨﻴﺎﺭﺍﺕ ﺍﻟﻤﻌﻘﺩﺓ -ﺒﺎﻟﻨﺴﺒﺔ ﻟﻲ - ﺘﺤﺩﺩ ﺒﻬـﺎ ﺴـﻠﻭﻙ ﺍﻟﻤﺘـﺭﺠﻡ ‪ ،Compiler‬ﺍﻻ ﺍﻥ‬
‫ﻓﺭﻴﻕ ﺍﻟﺘﻁﻭﻴﺭ ﻟـ ‪ Visual Studio .NET‬ﻗﺩ ﺴﻬﻠﻭﺍ ﻋﻠﻴﻨﺎ ﻋﻤل ﺫﻟﻙ ﺒﺘﺠﻬﻴـﺯ ﻫـﺫﻩ ﺍﻟﺨﻴـﺎﺭﺍﺕ ﺒﺸـﻜل‬

‫ﻤﺒﺩﺌﻲ ﺒﺤﻴﺙ ﻴﻨﺎﺴﺏ ﺍﻏﻠﺏ ﺍﻟﺤﺎﻻﺕ، ﺘﻌﺭﻑ ﻫﺫﻩ ﺍﻻﻋﺩﺍﺩﺍﺕ ﺒـ ‪ .Configurations‬ﺒﺸﻜل ﻤﺒـﺩﺌﻲ ﻴﻤﻜﻨـﻙ‬
‫ﺭﺅﻴﺔ ﺍﺤﺩ ﻫﺫﻩ ﺍﻻﻋﺩﺍﺩﺍﺕ ﻭﻫﻭ ﺍﻟﻨﺹ ﺍﻟﻤﻌﻨـﻭﻥ ‪ Debug‬ﻓـﻲ ﺸـﺭﻴﻁ ﺍﻻﺩﻭﺍﺕ ﺍﻟﻌﻠـﻭﻱ ﻟﺒﻴﺌـﺔ ﺍﻟﺘﻁـﻭﻴﺭ‬
‫‪) Visual Studio .NET‬ﺸﻜل 1 -31(:‬

‫ﺸﻜل 1 -31: ﺍﻋﺩﺍﺩﺍﺕ ﺍﻟﺘﺭﺠﻤﺔ‬
‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮف ﻋﻠﻰ ‪V isual Basic .NET‬‬
‫72‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺒﺎﻟﻨﺴﺒﺔ ﻟﻼﻋﺩﺍﺩﺍﺕ ‪ Release‬ﻓﺤﺩﺩﻫﺎ ﺍﺫﺍ ﻜﺎﻨﺕ ﻫﺫﻩ ﺍﺨﺭ ﻤﺭﺓ ﺘﻘﻭﻡ ﻓﻴﻬﺎ ﺒﻌﻤﻠﻴـﺔ ﺘﺭﺠﻤـﺔ ﺍﻟﺒﺭﻨـﺎﻤﺞ‬
‫ﻭﻋﻨﺩﻤﺎ ﺘﻜﻭﻥ ﺠﺎﻫﺯ ﻟﺘﻭﺯﻴﻊ ﺍﻟﺒﺭﻨﺎﻤﺞ. ﻴﻤﻜﻨﻙ ﺍﻀﺎﻓﺔ ﺍﻋﺩﺍﺩﺍﺕ ﺠﺩﻴـﺩﺓ ﺍﻭ ﺘﺤﺭﻴـﺭ ﻫـﺫﻩ ﺍﻻﻋـﺩﺍﺩﺍﺕ ﻭﺍﻟﺘـﻲ‬

‫ﺘﺠﺩﻫﺎ ﻓﻲ ﻗﺎﺌﻤﺔ ‪ Configuration Properties‬ﻤﻥ ﺍﺩﺍﺓ ﺍﻟﺸﺠﺭﺓ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺼﻨﺩﻭﻕ ﺤﻭﺍﺭ ﺨﺼـﺎﺌﺹ‬
‫ﺍﻟﻤﺸﺭﻭﻉ ‪.Project Properties‬‬
‫ﺍﺨﻴﺭﺍ، ﺍﺫﺍ ﺍﺭﺩﺕ ﺘﻭﺯﻴﻊ ﺒﺭﻨﺎﻤﺠﻙ ﺍﻟﻰ ﺍﺠﻬﺯﺓ ﺍﺨﺭﻯ ﻋﻠﻴﻙ ﺍﺭﻓـﺎﻕ ﻤﻜﺘﺒـﺎﺕ ‪.NET Framework‬‬

‫ﻤﻊ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺤﺘﻰ ﺘﻌﻤل، ﻴﻤﻜﻨﻙ ﺍﻨﺯﺍل ﻫﺫﻩ ﺍﻟﻤﻜﺘﺒﺎﺕ ﻤﻥ ﻤﻭﻗﻊ ‪ microsoft.com‬ﺍﻭ ﻴﻔﻀل ﺍﺭﻓﺎﻗﻬـﺎ ﻓـﻲ‬
‫ﺍﺴﻁﻭﺍﻨﺔ ﻤﺴﺘﻘﻠﺔ ﻻﻥ ﺤﺠﻤﻬﺎ ﻴﺯﻴﺩ ﻋﻥ 001 ﻤﻴﺠﺎ ﺒﺎﻴﺕ.‬

‫ﻗﺩ ﺘﻜﻭﻥ ﺍﺼﺒﺕ ﺒﺎﻻﺤﺒﺎﻁ ﺍﻟﻤﺒﺩﺌﻲ ﻤﻥ ﻫﺫﺍ ﺍﻟﻔﺼل ﻭﻟﻡ ﺘﺴﺘﻔﺩ ﻤﻨﻪ ﺍﻟﺸـﺊ ﺍﻟﻜﺜﻴـﺭ، ﻭﻟﻜـﻥ ﺼـﺩﻗﻨﻲ ﺍﻟﺒﺩﺍﻴـﺔ‬

‫ﺍﻟﺤﻘﻴﻘﻴﺔ ﺴﺘﻠﻤﺴﻬﺎ ﺍﻋﺘﺒﺎﺭﺍ ﻤﻥ ﺍﻟﻔﺼل ﺍﻟﺘﺎﻟﻲ ﻭﺤﺘﻰ ﻨﻬﺎﻴﺔ ﺍﻟﻜﺘﺎﺏ، ﻭﺴﺘﺭﻯ ﻤﺌـﺎﺕ ﺍﻻﺴـﻁﺭ ﻤـﻥ ﺍﻟﺸـﻴ ﻔﺭﺍﺕ‬
‫ﹰ‬
‫ﺍﻟﻤﺼﺩﺭﻴﺔ ﻤﻊ ﺸﺭﺡ ﻭﺍﻓﻲ ﻟﻜل ﺸﺊ ﻤﺒﻬﻡ ﻟﻡ ﺘﻔﻬﻤﻪ ﻓﻲ ﻫﺫﺍ ﺍﻟﻔﺼل، ﻓﻬـﺩﻓﻲ ﻫﻨـﺎ ﺘﻘـﺩﻴﻡ ﺠﻭﻟـﺔ ﺴـﺭﻴﻌﺔ‬

‫ﻭﻤﺒﺴﻁﺔ ﺠﺩﺍ ﺤﻭل ﺘﻘﻨﻴﺔ ‪ ،.NET‬ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ ‪ ،Visual Studio .NET‬ﻭﻁﺭﻴﻘﺔ ﻜﺘﺎﺒﺔ ﺍﻭل ﺒﺭﻨﺎﻤﺞ ﻟـﻙ‬
‫ﺒـ ‪ .Visual Basic .NET‬ﺇﻗﻠﺏ ﺍﻟﺼﻔﺤﺔ ﻟﺘﺒﺩﺃ ﺘﻌﻠﻡ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ‪ Visual Basic .NET‬ﻤﻥ ﺍﻟﺼـ ﻔﺭ‬
‫ﻓﻲ ﺍﻟﻔﺼل ﺍﻟﺘﺎﻟﻲ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ.‬
‫2‬

‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬

‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ‬
‫ﺇﻥ ﻜﻨﺕ ﺘﻌﺘﻘﺩ ﺒﺄﻨﻨﻲ ﺴﺄﺒﺩﺃ ﻤﻌﻙ ﻓﻲ ﺘﺼﻤﻴﻡ ﺍﻟﻨﻭﺍﻓﺫ ﻭﻭﻀﻊ ﺍﻷﺩﻭﺍﺕ ﻋﻠﻴﻬﺎ، ﻓﻴﺅﺴﻔﻨﻲ ﺍﺨﺒﺎﺭﻙ ﺃﻥ ﺍﻟﻭﻗـﺕ ﻤـﺎ‬
‫ﺯﺍل ﻤﺒﻜﺭﺍ ﺠﺩﺍ ﻟﻠﺤﺩﻴﺙ ﻋﻨﻬﺎ، ﺤﻴﺙ ﺍﻨﻲ ﻟﻥ ﺍﺘﻁﺭﻕ ﺍﻟﻰ ﻫﺫﻩ ﺍﻟﻤﻭﺍﻀﻴﻊ ﺇﻻ ﻤﻊ ﺒﺩﺍﻴـﺔ ﺍﻟﺠـﺯﺀ ﺍﻟﺜﺎﻟـﺙ ﻤـﻥ‬
‫ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﺘﻁﻭﻴﺭ ﺘﻁﺒﻴﻘﺎﺕ ‪ .Windows‬ﻭﻟﻭ ﻜﺎﻥ ﺍﻻﻤﺭ ﺒﻴـﺩﻱ، ﻟﻨﺼـﺤﺕ ﺠﻤﻴـﻊ ﻤﺒﺭﻤﺠـﻲ ‪Visual‬‬
‫‪ Basic .NET‬ﺍﻟﻌﺭﺏ ﺒﺄﻥ ﻻ ﻴﻘﻔﺯﻭﺍ ﺍﻟﻰ ﺒﺭﻤﺠﺔ ﻨﻤـﺎﺫﺝ ‪ Windows Forms‬ﺤﺘـﻰ ﻴﺘﻘﻨـﻭﺍ ﺃﺴﺎﺴـﻴﺎﺕ‬

‫ﺍﻟﻠﻐﺔ، ﻓﻤﺴﺄﻟﺔ ﺍﺘﻘﺎﻥ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ‪ Visual Basic .NET‬ﺃﻤﺭ ﻓﻲ ﻏﺎﻴﺔ ﺍﻷﻫﻤﻴﺔ ﻗﺒل ﺍﻻﻨﺘﻘﺎل ﺇﻟﻰ ﺘﻁـﻭﻴﺭ‬
‫ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﺍﻟﻤﺨﺘﻠﻔـﺔ ﻜــ ‪ ،Windows Applications‬ﺍﻭ ‪ ،Web Applications‬ﺍﻭ ‪Windows‬‬
‫‪... Services‬ﺍﻟﺦ، ﺨﺎﺼـﺔ ﺇﻥ ﻋﻠﻤـﺕ ﺃﻥ ‪ Visual Basic .NET‬ﻟـﻴﺱ ﻤﻭﺠﻬـﺎ ﻟﺘﻁـﻭﻴﺭ ﺘﻁﺒﻴﻘـﺎﺕ‬
‫ﹰ‬
‫‪ Windows‬ﻭﺤﺴﺏ، ﺒل ﻴﻤﻜﻨﻙ ﻤﻥ ﺇﻨﺠﺎﺯ ﺍﻷﻨﻭﺍﻉ ﺍﻟﻤﺨﺘﻠﻔﺔ ﻤﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ ﺍﻟﺘﻲ ﺘﻁﺭﻗﺕ ﺇﻟﻴﻬﺎ ﻓـﻲ ﺍﻟﻔﺼـل‬

‫ﺍﻟﺴﺎﺒﻕ.‬

‫ﺍﻋﺘﺒﺎﺭﺍ ﻤﻥ ﻫﺫﺍ ﺍﻟﻔﺼل ﻭﺤﺘﻰ ﺍﻟﻔﺼل ﺍﻟﺜﺎﻨﻲ ﻋﺸﺭ ﺴﻨﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻜﺎﺌﻥ ‪ ArabicConsole‬ﻟﻌـﺭﺽ‬
‫ﹰ‬

‫ﺍﻟﻤﺨﺭﺠﺎﺕ ﻋﻠﻰ ﺍﻟﺸﺎﺸﺔ، ﻭﺘﻭﻀﻴﺢ ﻨﺘﺎﺌﺞ ﺍﻟﺸﻴﻔﺭﺓ ﻟﺘـﺘﻌﻠﻡ ﻟﻐـﺔ ﺍﻟﺒﺭﻤﺠـﺔ ‪ Visual Basic .NET‬ﺒﺸـﻜل‬
‫ﺴﻠﻴﻡ. ﻭﺴﺎﻓﺘﺭﺽ ﺍﻥ ﻟﺩﻴﻙ ﺨﻠﻔﻴﺔ –ﻭﻟﻭ ﺒﺴﻴﻁﺔ - ﻓﻲ ﺍﻟﺒﺭﻤﺠﺔ ﺒﻐﺽ ﺍﻟﻨﻅﺭ ﻋـﻥ ﺍﻟﻠﻐـﺔ ﺍﻟﺘـﻲ ﺍﺴـﺘﺨﺩﻤﺘﻬﺎ،‬
‫ﺤﻴﺙ ﺃﻨﻰ ﻟﻥ ﺍﻀﻴﻊ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﻭﻗﺘﻲ ﻭﻭﻗﺘﻙ ﻓﻲ ﺸﺭﺡ ﺍﻟﻤﺴﺎﺌل ﺍﻟﻨﻅﺭﻴﺔ ) ﻜﺎﻟﺘﻜﺭﺍﺭ، ﺍﻟﺘﻔـﺭﻉ، ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ،‬
‫ﺍﻹﺠﺭﺍﺀﺍﺕ ...ﺍﻟﺦ( ﻓﻠﺩﻱ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﻤﺴﺎﺌل ﺍﻟﺘﻁﺒﻴﻘﻴﺔ ﻭﺍﻟﺘﻲ ﺴﺘﻭﻀﺢ ﻟﻙ ﻗﻀـﺎﻴﺎ ﺃﻫـﻡ ﺒﻜﺜﻴـﺭ ﻓـﻲ ﻟﻐـﺔ‬

‫ﺒﺭﻤﺠﺘﻙ ﺍﻟﺠﺩﻴﺩﺓ ‪.Visual Basic .NET‬‬

‫اﻟﻮﺣﺪات اﻟﺒﺮﻣﺠﻴﺔ ‪Modules‬‬

‫ﺍﻭل ﻤﺼﻁﻠﺢ ﺴﻨﺘﻌﺭﻑ ﻋﻠﻴﻪ ﻫﻭ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ ‪ ،Module‬ﻭﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﺤﺎﻭﻴﺔ ﺘﻤﻜﻨـﻙ ﻤـﻥ ﻜﺘﺎﺒـﺔ‬

‫ﺠﻤﻴﻊ ﺸﻴﻔﺭﺍﺘﻙ ﺍﻟﻤﺼﺩﺭﻴﺔ ﺒﺩﺍﺨﻠﻬﺎ، ﻓﻠﻭ ﻋﺩﺕ ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻷﻭل ﻓﻲ ﺍﻟﻔﺼل ﺍﻟﺴﺎﺒﻕ، ﺴﺘﻼﺤﻅ ﺃﻨﻨـﺎ ﻋﺭﻓﻨـﺎ‬
‫ﻭﺤﺩﺓ ﺒﺭﻤﺠﻴﺔ ﺒﺎﺴﻡ ‪ FirstProg‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪:Module‬‬
‫‪Module FirstProg‬‬
‫) (‪Sub Main‬‬
‫)"ﺑﺴ ﻢ اﷲ اﻟﺮﲪﻦ اﻟﺮﺣ ﻴﻢ" (‪ArabicConsole.WriteLine‬‬
‫‪End Sub‬‬
‫‪End Module‬‬
‫03‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻻ ﻴﻤﻜﻨﻙ ﻜﺘﺎﺒﺔ ﺃﻱ ﺸﻴﻔﺭﺓ ﺨﺎﺭﺝ ﻨﻁﺎﻕ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ )ﺃﻱ ﻓـﻭﻕ ﺍﻟﺴـﻁﺭ ‪ Module X‬ﻭﺘﺤـﺕ‬
‫ﺍﻟﺴﻁﺭ ‪ .(End Module‬ﻭﻟﻭ ﺘﺠﺭﺃﺕ ﻭﺼﺭﺤﺕ ﻋﻥ ﻤﺘﻐﻴﺭ ﺃﻭ ﺃﻋﻠﻨﺕ ﻋﻥ ﺇﺠﺭﺍﺀ ﺨـﺎﺭﺝ ﻨﻁـﺎﻕ ﺍﻟﻭﺤـﺩﺓ‬
‫ﺍﻟﺒﺭﻤﺠﻴﺔ، ﻓﺄﻨﺕ ﻋﻤﻠﻴﺎ ﺘﻜﺘﺏ ﺨﺎﺭﺝ ﻨﻁﺎﻕ ﺍﻟﺤﺎﻭﻴﺔ، ﻭﺴﻴﻅﻬﺭ ﻟﻙ ﺍﻟﻤﺘـﺭﺠﻡ ﺭﺴـﺎﻟﺔ ﺨﻁـﺄ ‪Statement is‬‬
‫ﹰ‬

‫‪:not valid in a namespace‬‬
‫ﻟﻦ ﻳﺘﻢ ﺗ ﻨﻔﻴﺬ اﻟﺸﻴﻔ ﺮة اﻟ ﺘﺎﻟﻴﺔ ﻟﻌﺪم وﺟﻮد ه ﺎ '‬
‫داﺧﻞ وﺣﺪة ﺑﺮﳎﻴ ﺔ ‪' Module‬‬
‫‪Dim X As Integer‬‬
‫)( ‪Sub Test‬‬
‫…‬
‫…‬
‫‪End Sub‬‬
‫‪Module FirstProg‬‬
‫…‬
‫…‬
‫‪End Module‬‬

‫ﻴﻤﻜﻥ ﻟﻠﻤﻠﻑ ﺍﻟﻭﺍﺤﺩ ﺃﻥ ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﺍﻜﺜﺭ ﻤﻥ ﻭﺤﺩﺓ ﺒﺭﻤﺠﻴـﺔ، ﻓ ﻘـﺩ ﺘﺭﻏـﺏ –ﻤـﺜﻼ - ﻓـﻲ ﺘﻘﺴـﻴﻡ‬

‫ﻭﺤﺩﺍﺘﻙ ﺍﻟﺒﺭﻤﺠﻴﺔ ﺍﺴﺘﻨﺎﺩﺍ ﺇﻟﻰ ﺘﺼﻨﻴﻑ ﻭﻅﺎﺌﻔﻬﺎ:‬

‫‪Module DrawingFunctions‬‬
‫…‬
‫…‬
‫‪End Module‬‬
‫‪Module InternetFunctions‬‬
‫…‬
‫…‬
‫‪End Module‬‬
‫‪Module SystemFunctions‬‬
‫…‬
‫…‬
‫‪End Module‬‬
‫…‬
‫…‬

‫ﺒﺎﻟﻨﺴﺒﺔ ﻟﺸﺭﻭﻁ ﺘﺴﻤﻴﺔ ﺍﻟﻭﺤﺩﺍﺕ ﺍﻟﺒﺭﻤﺠﻴﺔ ﻓﻬﻲ ﻤﺜل ﺸﺭﻭﻁ ﺘﺴـﻤﻴﺔ ﺒـﺎﻗﻲ ﺍﻟﻤﻌﺭﻓـﺎﺕ ‪Identifiers‬‬
‫ﺍﻻﺨﺭﻯ )ﻜﺎﻟﻤﺘﻐﻴﺭﺍﺕ، ﺍﻟﺘﺭﻜﻴﺒﺎﺕ، ﺍﻟﻔﺌﺎﺕ ...ﺍﻟﺦ( ﻭﻫﻲ:‬
‫‪S‬‬

‫ﺃﻥ ﻻ ﻴﺯﻴﺩ ﻋﺩﺩ ﺤﺭﻭﻑ ﺍﻟﻤﻌﺭﻑ ﻋﻥ 38361 ﺤﺭﻑ -ﻻ ﺍﻋﺘﻘﺩ ﺍﻨﻙ ﺒﺤﺎﺠـﺔ ﺍﻟـﻰ ﻜـل ﻫـﺫﺍ‬

‫‪S‬‬

‫ﺃﻥ ﻴﺒﺩﺃ ﺍﻟﻤﻌﺭﻑ ﺒﺤﺭﻑ ﺃﺒﺠﺩﻱ، ﻤﻊ ﺫﻟﻙ ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺸـﺭﻁﺔ ﺍﻟﺴـﻔﻠﻴﺔ "_" ﻜﺒﺩﺍﻴـﺔ ﻻﺴـﻡ‬

‫ﺍﻟﻌﺩﺩ!‬

‫ﺍﻟﻤﻌﺭﻑ ﻭﻟﻜﻥ ﻋﻠﻴﻙ ﺍﺘﺒﺎﻋﻬﺎ ﺒﺤﺭﻑ ﺃﺒﺠﺩﻱ ﻜﻲ ﻴﺘﻤﻜﻥ ﺍﻟﻤﺘﺭﺠﻡ ﻤﻥ ﺘﻤﻴﻴﺯﻫﺎ ﻋـﻥ ﺍﻟﻤﻌﺎﻤـل "_"‬

‫)ﺍﻟﺫﻱ ﻴﺴﺘﺨﺩﻡ ﻟﺘﻘﺴﻴﻡ ﺍﻷﻤﺭ ﺇﻟﻰ ﺍﻜﺜﺭ ﻤﻥ ﺴﻁﺭ(.‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫13‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫‪S‬‬

‫ﻻ ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﺴﻡ ﻴﻤﺜل ﻜﻠﻤﺔ ﻤﺤﺠﻭﺯﺓ ‪ Keyword‬ﻟﺘﻌﺭﻴﻑ ﻤﻌﺭﻑ ﺠﺩﻴﺩ. ﻭﺍﻥ ﻜـﺎﻥ ﻻﺒـﺩ‬
‫ﻤﻥ ﺫﻟﻙ، ﻓﺎﻜﺘﺏ ﺍﺴﻡ ﺍﻟﻤﻌﺭﻑ ﺩﺍﺨل ﺍﻟﻘﻭﺴـﻴﻥ ] ﻭ [ ) ﻤﺜـﺎل: ‪.( Dim [Dim] As Integer‬‬

‫ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻘﻭﺴﻴﻥ ] ﻭ [ ﺃﻴﻀﺎ ﻟﺘﻌﺭﻴﻑ ﻤﻌﺭﻓﺎﺕ ﺃﺨﺭﻯ ﻏﻴﺭ ﺍﻟﻜﻠﻤﺎﺕ ﺍﻟﻤﺤﺠﻭﺯﺓ.‬
‫ﹰ‬
‫ﻣﻼﺣﻈﺔ‬

‫ﺗﺴـﻤﺢ ﻟـﻚ ﻟﻐـﺔ اﻟﺒﺮﻣﺠـﺔ ‪ Visual Basic .NET‬ﺑﺎﺳـﺘﺨﺪام اﻟﺤـﺮوف اﻟﻌﺮﺑﻴـﺔ‬
‫ﻟﻜﺘﺎﺑﺔ اﺳﻤﺎء اﻟﻤﻌﺮﻓﺎت، ﻓﻬﻲ داﻋﻤﺔ ﻟﺠﺪول اﻟﺮﻣﻮز ‪ ، UNICODE‬إﻻ أﻧﻨﻲ ﻟﻢ‬
‫وﻟﻦ اﺳﺘﺨﺪﻣﻬﺎ ﻻ ﻓﻲ هﺬا اﻟﻜﺘﺎب وﻻ ﻓﻲ ﻣﺸﺎرﻳﻌﻲ اﻟﺨﺎ ﺻﺔ، ﻓﻼ اﻋﺘﻘﺪ اﻧﻚ‬
‫ﺗﻮد رؤﻳﺔ ﺷﻴﻔﺮة ﻣﺸﺎﺑﻬﺔ ﻟﻠﺸﻴﻔﺮة اﻟﺘﺎﻟﻴﺔ :‬
‫ﻓﺌﺔ ‪ A s New‬اﻟﻜﺎﺋﻦ ‪Dim‬‬
‫‪ A s Integer‬س ‪Dim‬‬
‫‪ = 23 Then‬ﺧﺎ ﺻﻴﺘﻪ.اﻟﻜﺎﺋﻦ ‪If‬‬
‫0 = ﺧﺎ ﺻﻴﺘﻪ2.اﻟﻜﺎﺋﻦ = س‬
‫‪End If‬‬
‫)س ,02( ﻃﺮﻳﻘﺔ.آﺎﺋﻦ_ﻣﺤ ﻀﻮن.اﻟﻜﺎﺋﻦ‬

‫ﺃﺨﻴﺭﹰ، ﻻ ﺘﺤﺎﻭل ﺘﻌﺭﻴﻑ ﺍﻜﺜﺭ ﻤﻥ ﻭﺤﺩﺓ ﺒﺭﻤﺠﻴﺔ ‪ Module‬ﺒﻨﻔﺱ ﺍﻻﺴﻡ ﻓﻲ ﺩﺍﺨل ﺍﻟﻤﺸـﺭﻭﻉ، ﺤﺘـﻰ‬
‫ﺍ‬

‫ﻭﺍﻥ ﺍﺨﺘﻠﻔﺕ ﺍﻟﻤﻠﻔﺎﺕ ﺍﻟﺘﺎﺒﻌﺔ ﻟﻬﺎ، ﻓﻬﺫﺍ ﻴﺴﺒﺏ ﺨﻁﺄ ﺘﻌﺎﺭﺽ ﺍﻷﺴﻤﺎﺀ :‬

‫ﻟﻦ ﺗﺘﻢ ﺗ ﺮﲨﺔ ا ﻟﺸﻴﻔﺮ ة اﻟﺘ ﺎﻟﻴﺔ ﻟﺘﻌﺎر ض '‬
‫اﺳﻢ اﻟ ﻮﺣﺪ ة ‪ MyModule‬ﰲ اﳌﻠﻔ ﲔ '‬
‫ﰲ اﳌﻠ ﻒ ‪' First.vb‬‬
‫‪Module MyModule‬‬
‫…‬
‫…‬
‫‪End Module‬‬
‫ﰲ اﳌﻠ ﻒ ‪' Second.vb‬‬
‫‪Module MyModule‬‬
‫…‬
‫…‬
‫‪End Module‬‬

‫ﻣﻼﺣﻈﺔ‬
‫ﻳﻤﻜﻨﻚ اﺳﺘﺨﺪام ﻧﻔﺲ اﻻﺳﻢ ﻟﺘﻌﺮﻳﻒ اآﺜﺮ ﻣﻦ وﺣﺪة ﺑﺮﻣﺠﻴﺔ ﺷﺮﻳﻄﺔ‬
‫ﺗﻌﺮﻳﻔﻬﺎ ﻓﻲ ﻣﺠﺎﻻت اﺳﻤﺎء ‪ Namespaces‬ﻣﺨﺘﻠﻔﺔ. ﺳﺄﺗﻄﺮق اﻟﻰ ﻣﺠﺎﻻت‬
‫اﻻﺳﻤﺎء ﻓﻲ اﻟﻘﺴﻢ اﻻﺧﻴﺮ ﻟ ﻬﺬا اﻟﻔ ﺼﻞ.‬
‫23‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫اﻹﺟﺮاء ‪Sub Main‬‬
‫ﺘﺴﺘﻁﻴﻊ ﺘﻌﺭﻴﻑ ﻋﺩﺩ ﻏﻴﺭ ﻤﺤﺩﻭﺩ ﻤﻥ ﺍﻻﺠﺭﺍﺀﺍﺕ ﻓﻲ ﺩﺍﺨل ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ ‪ Module‬ﺒﻤﺎ ﻟﺫ ﻭﻁـﺎﺏ ﻟـﻙ‬
‫ﻤﻥ ﺍﻻﺴﻤﺎﺀ ﺍﻟﺘﻲ ﺘﺭﻴﺩﻫﺎ، ﺍﻻ ﺍﻥ ﺍﻻﺠﺭﺍﺀ ﺍﻟﺫﻱ ﻴﺤﻤل ﺍﻻﺴﻡ ‪ Main‬ﻟﻪ ﻁـﺎﺒﻊ ﺨـﺎﺹ، ﻓﻬـﻭ ﻴﻤﻜﻨـﻙ ﻤـﻥ‬

‫ﺘﺨﺼﻴﺹ ﺍﻟﻤﺘﺭﺠﻡ ﻟﻴﻘﻭﻡ ﺒﺎﺴﺘﺩﻋﺎﺀ ﻫﺫﺍ ﺍﻻﺠﺭﺍﺀ ﻤﻊ ﺒﺩﺍﻴﺔ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ:‬

‫1‪Module Module‬‬
‫)(‪Sub Main‬‬
‫‪A‬‬
‫)"ﺑﺪاﻳ ﺔ اﻟﱪ ﻧﺎﻣﺞ ﻣﻦ هﻨ ﺎ"(‪ِ rabicConsole.WriteLine‬‬
‫‪End Sub‬‬
‫‪End Module‬‬

‫ﺍﻟﻤﺯﻴﺩ ﺍﻴﻀﺎ، ﺘﺴﺘﻁﻴﻊ ﺘﻌﺭﻴﻑ ﺍﻜﺜﺭ ﻤﻥ ﺍﺠﺭﺍﺀ ‪ Main‬ﻓﻲ ﺍﻜﺜﺭ ﻤﻥ ﻭﺤﺩﺓ ﺒﺭﻤﺠﻴﺔ:‬
‫1‪Module Module‬‬
‫)(‪Sub Main‬‬
‫)"ﻣﻦ ا ﻟﻮﺣﺪة اﻟﱪﳎ ﻴﺔ اﻻ و ﱃ"(‪ArabicConsole.WriteLine‬‬
‫‪End Sub‬‬
‫‪End Module‬‬
‫2‪Module Module‬‬
‫)(‪Sub Main‬‬
‫)"ﻣﻦ ا ﻟﻮﺣﺪة اﻟﱪﳎ ﻴﺔ اﻟ ﺜﺎﻧﻴ ﺔ"(‪ArabicConsole.WriteLine‬‬
‫‪End Sub‬‬
‫‪End Module‬‬

‫ﻭﺍﻟﺴﺅﺍل ﺍﻟﺫﻱ ﻴﻁﺭﺡ ﻨﻔﺴﻪ، ﺃﻱ ﻤﻥ ﺍﻻﺠﺭﺍﺌﻴﻥ ‪ Main‬ﺍﻟﺴﺎﺒﻘﻴﻥ ﺴﻴﺘﻡ ﺍﺴﺘﺩﻋﺎﺌﻪ ﻤﻊ ﺒﺩﺍﻴـﺔ ﺘﻨﻔﻴـﺫ ﺍﻟﺒﺭﻨـﺎﻤﺞ؟‬
‫ﻭﺍﻟﺠﻭﺍﺏ ﻫﻭ ﻜﺎﺌﻥ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺫﻱ ﺘﺤﺩﺩﻩ ﻓـﻲ ﺨﺎﻨـﺔ ‪ Startup Object‬ﻤـﻥ ﻨﺎﻓـﺫﺓ ‪Project Property‬‬

‫‪) Pages‬ﺸﻜل 2 -1(. ﺴﺘﻅﻬﺭ ﺭﺴﺎﻟﺔ ﺨﻁﺄ ﺍﺫﺍ ﺍﺨﺘﺭﺕ ﻭﺤﺩﺓ ﺒﺭﻤﺠﻴﺔ ‪ Module‬ﻟﻡ ﻴﻌـﺭﻑ ﺒﻬـﺎ ﺍﺠـﺭﺍﺀ‬

‫ﺒﺎﺴﻡ ‪ ،Main‬ﻜﻤﺎ ﺴﺘﻅﻬﺭ ﻨﻔﺱ ﺭﺴﺎﻟﺔ ﺍﻟﺨﻁﺄ ﺍﻥ ﺤـﺩﺩﺕ ﺍﻻﺨﺘﻴـﺎﺭ ‪) Sub Main‬ﺍﻟﻤﻭﺠـﻭﺩ ﻓـﻲ ﻨﻔـﺱ‬
‫ﺍﻟﻘﺎﺌﻤﺔ( ﺍﻥ ﻭﺠﺩ ﺍﻻﺠﺭﺍﺀ ‪ Main‬ﻓﻲ ﺍﻜﺜﺭ ﻤﻥ ﻭﺤﺩﺓ ﺒﺭﻤﺠﻴﺔ ﺍﻭ ﻟﻡ ﻴﺘﻡ ﺘﻌﺭﻴﻔﻪ ﻓﻲ ﺍﻱ ﻭﺤﺩﺓ ﺒﺭﻤﺠﻴﺔ.‬

‫ﺸﻜل 2 -1: ﺘﺤﺩﻴﺩ ﺍﻻﺠﺭﺍﺀ ﺍﻻﺒﺘﺩﺍﺌﻲ ﻟﻠﻤﺸﺭﻭﻉ.‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫33‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫اﻻﺟﺮاء ‪Sub New‬‬
‫ﺍﺠﺭﺍﺀ ﺍﺨﺭ ﻟﻪ ﻁـﺎﺒﻊ ﺨـﺎﺹ ﻴﺤﻤـل ﺍﻻﺴـﻡ ‪ ،New‬ﻴﻌـﺭﻑ ﻫـﺫﺍ ﺍﻟﻨـﻭﻉ ﻤـﻥ ﺍﻻﺠـﺭﺍﺀﺍﺕ ﺒﺎﻟﻤﺸـﻴﺩ‬
‫‪ ،Constructor‬ﻭﻫﻭ ﻋﺒﺎﺭﺓ ﻋﻥ ﺍﺠﺭﺍﺀ ﻴﺘﻡ ﺘﻨﻔﻴﺫﻩ ﺒﻤﺠﺭﺩ ﺍﻨﺸﺎﺀ ﻨﺴﺨﺔ ﻤﻥ ﺍﻟﻜﺎﺌﻥ ﺍﻟﺘـﺎﺒﻊ ﻟـﻪ. ﻓﻠـﻭ ﻜﺎﻨـﺕ‬
‫ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻫﻲ ﺍﻭل ﻭﺤﺩﺓ ﻴﺘﻡ ﺘﻨﻔﻴﺫﻫﺎ ﻓﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ، ﻓﺴﻴﺘﻡ ﺘﻨﻔﻴﺫ ﺍﻻﺠﺭﺍﺀ ‪ New‬ﻗﺒل ‪:Main‬‬

‫1‪Module Module‬‬
‫)(‪Sub New‬‬
‫)"ﺳﻴﺘﻢ ﺗ ﻨﻔﻴﺬ اﳌﺸﻴ ﺪ ‪ New‬او ﻻ"(‪ArabicConsole.WriteLine‬‬
‫‪End Sub‬‬
‫)(‪Sub Main‬‬
‫)"ﰒ ﺗﻨ ﻔﻴﺬ ا ﻻﺟﺮاء اﻟﺮﺋ ﻴﺴ ﻲ ‪ArabicConsole.WriteLine("Main‬‬
‫‪End Sub‬‬
‫‪End Module‬‬

‫اﻧﻈﺮ اﻳﻀﺎ‬
‫ﺗﺠﺪ اﻟﻤﺰﻳﺪ ﻣﻦ اﻟﺘﻔﺎ ﺻﻴﻞ واﻟﺘﻄﺒﻴﻘﺎت ﺣﻮل اﻟﻤﺸﻴﺪات ‪ Constructors‬ﻓﻲ‬
‫اﻟﻔ ﺼﻞ اﻟﺮاﺑﻊ اﻟﻔﺌﺎت واﻟ ﻜﺎﺋﻨﺎت .‬

‫ﻋﻠﻴﻙ ﻤﻌﺭﻓﺔ ﺍﻥ ﺍﻟﻤﺸﻴﺩﺍﺕ ﻓﻲ ﺍﻟﻭﺤﺩﺍﺕ ﺍﻟﺒﺭﻤﺠﻴـﺔ ﻻ ﻴـﺘﻡ ﺘﻨﻔﻴـﺫﻫﺎ ﺍﻻ ﺍﻥ ﻗﻤـﺕ ﺒﺎﺴـﺘﺩﻋﺎﺀ ﺍﺤـﺩ‬
‫ﺍﺠﺭﺍﺀﺍﺕ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ ﺍﻭ ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﺍﺤﺩ ﻤﺘﻐﻴﺭﺍﺘﻬـﺎ، ﻓﺎﻟﻤﺸـﻴﺩ ﺍﻟﻤﻭﺠـﻭﺩ ﻓـﻲ ﺍﻟﻭﺤـﺩﺓ ﺍﻟﺒﺭﻤﺠﻴـﺔ‬
‫2‪ Module‬ﺍﻟﺘﺎﻟﻴﺔ ﻟﻥ ﻴﺘﻡ ﺘﻨﻔﻴﺫﻩ، ﻭﺫﻟﻙ ﻻﻨﻨﺎ ﻟﻡ ﻨﺴﺘﺨﺩﻡ ﺍﻱ ﻋﻀﻭ ﻤﻥ ﺍﻋﻀـﺎﺀ ﺍﻟﻭﺤـﺩﺓ ﺍﻟﺒﺭﻤﺠﻴـﺔ ﺍﻟﺘﺎﺒﻌـﺔ‬

‫ﻟﻪ:‬
‫1‪Module Module‬‬
‫)(‪Sub New‬‬
‫)"ﺳﻴﺘﻢ ﺗ ﻨﻔﻴﺬ اﳌﺸﻴ ﺪ ‪ New‬او ﻻ"(‪ArabicConsole.WriteLine‬‬
‫‪End Sub‬‬
‫)(‪Sub Main‬‬
‫)"ﰒ ﺗﻨ ﻔﻴﺬ ا ﻻﺟﺮاء اﻟﺮﺋ ﻴﺴ ﻲ ‪ArabicConsole.WriteLine("Main‬‬
‫‪End Sub‬‬
‫‪End Module‬‬
‫2‪Module Module‬‬
‫)(‪Sub New‬‬
‫)"ﻟﻦ ﻳ ﺘﻢ ﺗﻨ ﻔﻴﺬ ه ﺬا اﳌ ﺸﻴ ﺪ"(‪ArabicConsole.WriteLine‬‬
‫‪End Sub‬‬
‫‪End Module‬‬
‫43‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫اﻟﻤﺘﻐﻴﺮات واﻟﺜﻮاﺑﺖ‬
‫ﻻ ﻴﺨﺘﻠﻑ ﻤﺒﺭﻤﺠﺎﻥ ﺍﺜﻨﺎﻥ ﻋﻠﻰ ﺍﻫﻤﻴﺔ ﻤﻭﻀﻭﻉ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻓﻲ ﺃﻱ ﻟﻐﺔ ﺒﺭﻤﺠـﺔ، ﻭﺇﺫﺍ ﻜـﺎﻥ ﺃﺴـﺎﺱ ﺇﺘﻘـﺎﻥ‬
‫ﺍﻟﻠﻐﺎﺕ ﺍﻟﻁﺒﻴﻌﻴﺔ ﻫﻭ ﺘﻌﻠﻡ ﺤﺭﻭﻑ ﻭﻤﻔﺭﺩﺍﺕ ﺘﻠﻙ ﺍﻟﻠﻐﺔ، ﻓﺎﻥ ﺍﺴﺎﺱ ﺍﺘﻘﺎﻥ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﻫﻭ ﺘﻌﻠﻡ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ‬

‫ﻭﺍﻟﺜﻭﺍﺒﺕ ﺍﻟﺘﻲ ﺘﺒﻨﻲ ﺒﻬﺎ ﺍﺠﺭﺍﺀﺍﺕ ﺒﺭﺍﻤﺠﻙ. ﻨﻅﺭﻴﺎ، ﻻ ﺘﺨﺘﻠـﻑ ﻓﻜـﺭﺓ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﻓـﻲ ‪Visual Basic‬‬
‫‪ .NET‬ﻋﻥ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻘﺩﻴﻤﺔ، ﻭﻟﻜﻨﻬﺎ ﺘﺨﺘﻠﻑ ﺍﺨﺘﻼﻓﺎ ﺠﺫﺭﻴﺎ ﻓﻲ ﺒﻨﻴﺘﻬﺎ ﺍﻟﺘﺤﺘﻴﺔ ﻋﻤﺎ ﻜﺎﻨـﺕ ﻋﻠﻴـﻪ ﻓـﻲ‬
‫ﹰ‬
‫ﹰ‬

‫ﺍﻟﺴﺎﺒﻕ ﻜﻤﺎ ﺴﺘﺭﻯ ﻻﺤﻘﺎ.‬

‫اﻟﺘﺼﺮﻳﺢ ﻋﻦ اﻟﻤﺘﻐﻴﺮات‬
‫ﻤﺎ ﺯﺍﻟﺕ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Dim‬ﺘﺴﺘﺨﺩﻡ ﻟﻠﺘﺼﺭﻴﺢ ﻋﻥ ﻤﺘﻐﻴﺭ ﺠﺩﻴﺩ ﺒﺭﻓﻘﺔ ﺍﻟﻤﻌﺎﻤل ‪ As‬ﺍﻟـﺫﻱ ﻴﺤـﺩﺩ ﻨـﻭﻉ‬
‫ﺍﻟﻤﺘﻐﻴﺭ:‬
‫ﻣﺘﻐﲑ ﻣ ﻦ اﻟﻨ ﻮ ع ‪' Integer‬‬
‫‪Dim Age As Integer‬‬
‫ﻣﺘﻐﲑا ن ﻣﻦ اﻟﻨﻮ ع ‪' String‬‬
‫‪Dim FirstName As String‬‬
‫‪Dim LastName As String‬‬

‫ﻓﻲ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ ﻋﺭﻓﺕ ﻤﺘﻐﻴﺭﻴﻥ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ String‬ﻓﻲ ﺴﻁﺭﻴﻥ ﻤﻨﻔﺼﻠﻴﻥ، ﻤﻊ ﺫﻟـﻙ ﻴﻤ ﹼﻨـﻙ ‪Visual‬‬
‫ﻜ‬
‫‪ Basic .NET‬ﻤﻥ ﺩﻤﺠﻬﻤﺎ ﻓﻲ ﺴﻁﺭ ﻭﺍﺤﺩ:‬
‫‪Dim Age As Integer‬‬
‫‪Dim FirstName, LastName As String‬‬

‫ﺍﻭ ﺩﻤﺞ ﺘﺼﺎﺭﻴﺢ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﺜﻼﺜﺔ ﻜﻠﻬﺎ ﻓﻲ ﺴﻁﺭ ﻭﺍﺤﺩ –ﺒﺎﻟﺭﻏﻡ ﻤﻥ ﺍﺨﺘﻼﻑ ﺍﻨﻭﺍﻋﻬﺎ:‬
‫ﻻ اﻧﺼﺤﻚ ﺑﺘﻌﺮﻳ ﻒ اﻧﻮ اع ﳐﺘ ﻠﻔﺔ ﻣ ﻦ '‬
‫اﳌﺘﻐﲑات ﰲ ﺳﻄﺮ واﺣ ﺪ '‬
‫‪Dim FirstName, LastName As String, Age As Integer‬‬

‫ﻴﻨﺼﺢ ﺩﺍﺌﻤﺎ ﺒﺘﺤﺩﻴﺩ ﻨﻭﻉ ﺍﻟﻤﺘﻐﻴﺭ ﻋﻨﺩ ﺍﻟﺘﺼﺭﻴﺢ ﻋﻨﻪ، ﻭﺍﻥ ﻟﻡ ﺘﺤـﺩﺩ ﻨـﻭﻉ ﺍﻟﻤﺘﻐﻴـﺭ ﻓﺴـﻴﻜﻭﻥ ﻨﻭﻋـﻪ‬
‫ﺒﺸﻜل ﻤﺒﺩﺌﻲ ‪ ،Object‬ﻭﺴﻴﺘﻡ ﺘﺤﻭﻴﻠﻪ ﺍﻟﻰ ﻨﻭﻉ ﺍﺨﺭ ﺘﻤﺎﺜل ﻨﻭﻉ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺘﻲ ﺘﺴﻨﺩﻫﺎ ﺍﻟﻴﻪ:‬
‫‪Dim X‬‬
‫اﺻﺒﺢ اﳌﺘﻐﲑ هﻨﺎ ﻣﻦ اﻟ ﻨﻮ ع ‪' Integer‬‬
‫وهﻨﺎ اﺻﺒ ﺢ ‪' String‬‬

‫01 = ‪X‬‬
‫"01" = ‪X‬‬

‫ﻤﻊ ﺍﻥ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﺴﺎﺒﻘﺔ ﺘﻌﻁﻴﻙ ﻤﺭﻭﻨﺔ ﻜﺒﻴﺭﺓ ﻓﻲ ﺘﺸﻜﻴل ﻭﺘﻐﻴﻴﺭ ﻨﻭﻉ ﺍﻟﻤﺘﻐﻴﺭ ﻤـﻥ ﻭﻗـﺕ ﻻﺨـﺭ، ﺍﻻ ﺍﻨﻬـﺎ‬
‫ﺘﺴﺒﺏ ﺒﻁﺌﺎ ﻜﺒﻴﺭﺍ ﻓﻲ ﻋﻤﻠﻴﺔ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ، ﻭﺍﻟﺴﺒﺏ ﻫﻭ ﺍﻀﻁﺭﺍﺭ ﺍﻟﻤﺘـﺭﺠﻡ ﺍﻟـﻰ ﺍﻟﻘﻴـﺎﻡ ﺒﺠﻬـﺩ ﺍﻀـﺎﻓﻲ‬
‫ﹰ‬
‫ﹰ‬
‫ﻟﺘﺤﻭﻴل ﻨﻭﻉ ﺍﻟﻤﺘﻐﻴﺭ.‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫53‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺍﻟﻌﺒﺎﺭﺓ ‪:Option Explicit‬‬
‫ﻤﺒﺩﺌﻴﺎ، ﻋﻤﻠﻴﺔ ﺍﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺃﻤﺭ ﺍﻟﺯﺍﻤﻲ ﻋﻠﻴﻙ ﻗﺒل ﺍﺴـﺘﺨﺩﺍﻡ ﺍﻟﻤﺘﻐﻴـﺭ، ﺍﻤـﺎ ﺍﻥ ﻜﺎﻨـﺕ ﺍﻟﻌﺒـﺎﺭﺓ‬

‫‪ Option Explicit Off‬ﻤﺴﻁﻭﺭﺓ ﻓﻲ ﺍﻋﻠﻰ ﺍﻟﻤﻠﻑ، ﻓﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻭﺍﻟﺘﻌﺎﻤل ﻤﻌﻬـﺎ ﻤﺒﺎﺸـﺭﺓ‬
‫ﺩﻭﻥ ﺍﻟﺤﺎﺠﺔ ﻟﻠﺘﺼﺭﻴﺢ ﻋﻨﻬﺎ ﺒـ ‪:Dim‬‬
‫‪Option Explicit Off‬‬
‫1‪Module Module‬‬
‫)(‪Sub Main‬‬
‫ﻣﺘﻐﲑ ﺟ ﺪﻳﺪ ا ﺳﺘﺨﺪﻣ ﺘﻪ ﻣﺒ ﺎﺷﺮ ة '‬
‫دون ﺗ ﻌﺮﻳﻔﻪ ﺑ ـ ‪' Dim‬‬
‫"ﺗﺮآﻲ اﻟ ﻌﺴﲑ ي" = ‪programmerName‬‬
‫) ‪ArabicConsole.Writeline ( programmerName‬‬
‫‪End Sub‬‬
‫‪End Module‬‬

‫ﺼﺤﻴﺢ ﺍﻥ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ ﺴﺘﻭﻓﺭ ﻋﻠﻴﻙ ﻋﻨﺎﺀ ﺍﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ، ﺇﻻ ﺃﻥ ﻫﺫﺍ ﺍﻷﺴـﻠﻭﺏ ﻏﻴـﺭ ﻤﺤﺒـﺫ‬
‫ﺒﺸﻜل ﻜﺒﻴﺭ ﻟﺩﻯ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺍﻟﺠﺎﺩﻴﻥ، ﺍﻻﺨﻁﺎﺀ ﺍﻻﻤﻼﺌﻴﺔ ﻫﻲ ﺍﺤﺩ ﺍﻻﺴﺒﺎﺏ:‬

‫ﳐﺮﺟﺎت اﻻ ﻣﺮ اﻟ ﺘﺎﱄ ﻻ ﺷﺊ ﺑ ﺴﺒﺐ ا ﳋﻄﺄ ا ﻻﻣﻼﺋﻲ ﰲ '‬
‫آﺘﺎﺑﺔ اﺳ ﻢ اﳌﺘ ﻐﲑ اﻟ ﺴﺎﺑ ﻖ '‬
‫) ‪ArabicConsole.Writeline ( programerName‬‬

‫ﺴﺒﺏ ﺍﺨﺭ ﻗﺩ ﻴﺠﻌﻠﻙ ﺘﺭﻓﺽ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻌﺒﺎﺭﺓ ‪ Option Explicit Off‬ﻭﻫﻭ ﺍﻥ ﺠﻤﻴـﻊ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ‬
‫ﺴﺘﻜﻭﻥ ﺒﺸﻜل ﺍﺒﺘﺩﺍﺌﻲ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Object‬ﻭﻓﻲ ﻜل ﻤﺭﺓ ﺘﺴﻨﺩ ﻗﻴﻤﺔ ﺠﺩﻴﺩﺓ ﺴﻴﺘﻡ ﺘﺤﻭﻴـل ﻨـﻭﻉ ﺍﻟﻤﺘﻐﻴـﺭ ﺍﻟـﻰ‬
‫ﺍﻟﻨﻭﻉ ﺍﻟﻤﻤﺎﺜل ﻟﻠﻘﻴﻤﺔ ﺍﻟﻤﺴﻨﺩﺓ ﺍﻟﻴﻪ، ﻤﻤﺎ ﻴﺴﺒﺏ ﺒﻁﺌﺎ ﻓﻲ ﻋﻤﻠﻴﺔ ﺍﻟﺘﻨﻔﻴﺫ.‬
‫ﹰ‬

‫ﻋﻠﻴﻙ ﺍﻻﺨﺫ ﺒﻌﻴﻥ ﺍﻻﻋﺘﺒﺎﺭ ﺍﻥ ﺘﺄﺜﻴﺭ ﺍﻟﻌﺒﺎﺭﺓ ‪ Option Explicit Off‬ﻴﺸﻤل ﺍﻟﻤﻠـﻑ ﺍﻟﺤـﺎﻟﻲ ﺍﻟـﺫﻱ‬
‫ﺴﻁﺭﺕ ﻓﻴﻪ ﺍﻟﻌﺒﺎﺭﺓ ﻓﻘﻁ. ﻭﺒﺩﻻ ﻤﻥ ﻜﺘﺎﺒﺘﻬﺎ ﻓﻲ ﻜﺎﻓﺔ ﻤﻠﻔﺎﺕ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻻﺨﺭﻯ، ﻴﻤﻜﻨﻙ ﺍﺨﺘﻴـﺎﺭ ﺍﻟﻘﻴﻤـﺔ ‪Off‬‬
‫ﻤﻥ ﻗﺎﺌﻤﺔ ‪ Option Explicit‬ﻓﻲ ﺨﺎﻨﺔ ﺍﻟﺘﺒﻭﻴـﺏ ‪ Build‬ﻤـﻥ ﻨﺎﻓـﺫﺓ ﺨﺼـﺎﺌﺹ ﺍﻟﻤﺸـﺭﻭﻉ ‪Project‬‬
‫‪) Property Pages‬ﺸﻜل 2 -2(.‬
‫63‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺸﻜل 2 -2: ﺘﻐﻴﻴﺭ ﻗﻴﻤﺔ ‪ Option Explicit‬ﻤﻥ ‪ On‬ﺍﻟﻰ ‪.Off‬‬

‫ﻗﺎﺑﻠﻴﺔ اﻟﺮؤﻳﺔ وﻋﻤﺮ اﻟﻤﺘﻐﻴﺮات‬

‫ﻗﺎﺒﻠﻴﺔ ﺍﻟﺭﺅﻴﺔ ‪ Visibility‬ﺍﻭ ﺍﻟﻤﺩﻯ ‪ Scope‬ﻟﻠﻤﺘﻐﻴﺭ ﺘﻤﺜل ﻗﺩﺭﺓ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻋﻠـﻰ ﺍﻟﻭﺼـﻭل ﺍﻟـﻰ ﺍﻟﻤﺘﻐﻴـﺭ‬

‫ﻭﺍﺴﺘﺨﺩﺍﻤﻪ، ﻓﺎﻟﻤﺘﻐﻴﺭ ‪ X‬ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ ﺍﻻﺠﺭﺍﺀ 1‪ MySub‬ﺍﻟﺘﺎﻟﻲ، ﻻ ﻴﻤﻜﻨﻙ ﺍﻟﻭﺼﻭل ﺍﻟﻴﻪ ﻭﺍﺴـﺘﺨﺩﺍﻤﻪ ﻤـﻥ‬
‫ﺨﺎﺭﺝ ﺍﻻﺠﺭﺍﺀ:‬
‫)( 1‪Sub MySub‬‬
‫‪Dim X As Integer‬‬
‫02 = ‪X‬‬
‫‪End Sub‬‬
‫)( 2‪Sub MySub‬‬
‫ﻻ ﳝﺜ ﻞ اﳌﺘ ﻐ ﲑ ‪ X‬اﻟﺴﺎﺑ ﻖ '‬
‫)‪ArabicConsole.WriteLine (X‬‬
‫‪End Sub‬‬

‫ﺍﻤﺎ ﻋﻤﺭ ‪ Lifetime‬ﺍﻟﻤﺘﻐﻴﺭ، ﻓﺘﻤﺜل ﺍﻟﻔﺘﺭﺓ ﺍﻟﺘﻲ ﻴﻅل ﻓﻴﻬﺎ ﺍﻟﻤﺘﻐﻴﺭ ﻤﺤﺘﻔﻅـﺎ ﺒﻘﻴﻤﺘـﻪ، ﻓـﺎﻟﻤﺘﻐﻴﺭ ‪X‬‬
‫ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ، ﺴﻴﻨﺘﻬﻲ ﻭﻴﻔﻘﺩ ﺍﻟﻘﻴﻤﺔ 02 ﺍﻟﺘﻲ ﻜﺎﻥ ﻤﺤﺘﻔﻅﺎ ﺒﻬﺎ ﺒﻤﺠـﺭﺩ ﺍﻻﻨﺘﻬـﺎﺀ ﻤـﻥ ﺘﻨﻔﻴـﺫ‬
‫ﺍﻻﺠﺭﺍﺀ 1‪ .MySub‬ﻭﺤﺘﻰ ﺘﻔﻬﻡ ﺍﻻﺴﻠﻭﺏ ﺍﻟﺫﻱ ﻴﺘﺒﻌﻪ ‪ Visual Basic .NET‬ﻟﺘﻁﺒﻴﻕ ﻤﻔﻬـﻭﻤﻲ ﻗﺎﺒﻠﻴـﺔ‬

‫ﺍﻟﺭﺅﻴﺔ ﻭﺍﻟﻌﻤﺭ ﻟﻠﻤﺘﻐﻴﺭ، ﻋﻠﻴﻙ ﻤﻌﺭﻓﺔ ﺍﻨﻭﺍﻉ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻤﻥ ﻤﻨﻅﻭﺭ ﺍﻟﺭﺅﻴﺔ ﻭﺍﻟﻌﻤﺭ:‬
‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺤﻠﻴﺔ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴﺔ:‬
‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺤﻠﻴﺔ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴﺔ ‪ Dynamic Local Variables‬ﻫﻲ ﻤﺘﻐﻴﺭﺍﺕ ﻴﺘﻡ ﺍﻻﻋـﻼﻥ ﻋﻨﻬـﺎ ﺩﺍﺨـل‬
‫ﺍﻻﺠﺭﺍﺀﺍﺕ، ﻭﻋﻤﺭ ﺍﻟﻤﺘﻐﻴﺭ ﻴﺒﺩﺃ ﻤﻥ ﺍﻟﺴﻁﺭ ﺍﻟﺫﻱ ﺘﺼﺭﺡ ﻓﻴﻪ ﻋﻥ ﺍﻟﻤﺘﻐﻴﺭ ﻭﻴﻨﺘﻬﻲ ﺒﻌﺩ ﺍﻻﻨﺘﻬـﺎﺀ ﻤـﻥ ﺘﻨﻔﻴـﺫ‬

‫ﺍﻻﺠﺭﺍﺀ. ﺍﻤﺎ ﺒﺎﻟﻨﺴﺒﺔ ﻟﻘﺎﺒﻠﻴﺔ ﺍﻟﺭﺅﻴﺔ ﻓﻬﻲ ﻤﺤﺼﻭﺭﺓ ﺩﺍﺨل ﺍﻻﺠﺭﺍﺀ ﺍﻟﺫﻱ ﺼﺭﺤﺕ ﻓﻴﻪ ﻓﻘﻁ. ﺘﺴـﺘﺨﺩﻡ ﺍﻟﻜﻠﻤـﺔ‬
‫ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Dim‬ﺍﻴﻀﺎ ﻟﻠﺘﺼﺭﻴﺢ ﻋﻥ ﻤﺘﻐﻴﺭ ﻤﺤﻠﻲ ﺩﻴﻨﺎﻤﻴﻜﻲ.‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫73‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺘﻘﺘﺭﺡ ﻋﻠﻴﻙ ﻤﺴﺘﻨﺩﺍﺕ ‪ Microsoft .NET‬ﺍﺴﺘﺨﺩﺍﻡ ﺍﺴﻠﻭﺏ ﻴﺴﻤﻰ ‪ smallCase‬ﻓﻲ ﺘﺴـﻤﻴﺔ ﻫـﺫﺍ‬
‫ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ، ﺒﺤﻴﺙ ﺘﻜﻭﻥ ﺍﻟﻜﻠﻤﺔ ﺍﻻﻭﻟﻰ ﺼﻐﻴﺭﺓ ﺍﻟﺤﺭﻭﻑ ‪ small‬ﻭﺍﻟﺤـﺭﻑ ﺍﻻﻭل ﻤـﻥ ﺍﻟﻜﻠﻤـﺎﺕ‬
‫ﺍﻻﺨﺭﻯ ﻜﺒﻴﺭ ‪ .Capital‬ﺍﻤﺜﻠﺔ:‬

‫‪Dim programmerName As String‬‬
‫‪Dim userID as Integer‬‬
‫‪Dim employeeSalary As Decimal‬‬

‫ﺒﻌﻴﺩﺍ ﻋﻥ ﻤﻭﻀﻭﻉ ﺍﻟﺘﺴﻤﻴﺔ، ﻴﻭﺠﺩ ﻨﻭﻉ ﺨﺎﺹ ﻤﻥ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺍﻟﻤﺤﻠﻴـﺔ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴـﺔ ﻴﻌـﺭﻑ ﺒﺎﻟــ‬

‫‪ ،Block level Variables‬ﻭﻫﻲ ﻤﺘﻐﻴﺭﺍﺕ ﻴﺘﻡ ﺘﻌﺭﻴﻔﻬﺎ ﺩﺍﺨل ﺘﺭﻜﻴﺏ ‪) Block‬ﻜﺤﻠﻘـﺔ ‪،For … Next‬‬
‫ﺠﻤﻠﺔ ‪ ،If … Then‬ﺤﻠﻘﺔ ‪ Do … Loop‬ﻭﻏﻴﺭﻫﺎ(. ﻤﺩﻯ ﻫـﺫﻩ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﻴﻜـﻭﻥ ﻤﺤﺼـﻭﺭﺍ ﺩﺍﺨـل‬
‫ﹰ‬
‫ﺍﻟﺘﺭﻜﻴﺏ ﺍﻟﺫﻱ ﺍﻋﻠﻨﺕ ﻓﻴﻪ ﻋﻥ ﺍﻟﻤﺘﻐﻴﺭ، ﻭﻋﻤﺭﻫﺎ ﻤﺜل ﻋﻤﺭ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺤﻠﻴـﺔ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴـﺔ ﺍﻟﺴـﺎﺒﻘﺔ. ﻫـﺫﺍ‬
‫ﻤﺘﻐﻴﺭ ﻴﺤﻤل ﺍﻻﺴﻡ ‪ y‬ﻋﺭﻑ ﺩﺍﺨل ﺤﻠﻘﺔ ‪:For … Next‬‬

‫‪Dim counter As Integer‬‬
‫01 ‪For counter = 1 To‬‬
‫‪Dim y as integer‬‬
‫…‬
‫…‬
‫‪Next‬‬

‫ﻻ ﺘﺤﺎﻭل ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﺘﻐﻴﺭ ﺍﻟﻤﻌﺭﻑ ﻓﻲ ﺩﺍﺨل ﺘﺭﻜﻴﺏ ﺨﺎﺭﺝ ﻫﺫﺍ ﺍﻟﺘﺭﻜﻴﺏ، ﻓﻤﺩﻯ ﻫـﺫﺍ ﺍﻟﻨـﻭﻉ ﻤـﻥ‬
‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ –ﻜﻤﺎ ﻗﻠﺕ - ﻤﺤﺼﻭﺭ ﺩﺍﺨل ﺍﻟﺘﺭﻜﻴﺏ ﻓﻘﻁ:‬
‫‪Dim x As Integer‬‬
‫‪If x = 0 Then‬‬
‫‪Dim y As Integer‬‬
‫…‬
‫…‬
‫‪End If‬‬
‫رﺳﺎﻟﺔ ﺧ ﻄ ﺄ '‬

‫‪x = y‬‬

‫ﻜﻤﺎ ﺃﻨﻙ ﻻ ﺘﺴﺘﻁﻴﻊ ﺍﺴﺘﺨﺩﺍﻡ ﺍﺴﻡ ﻤﺘﻐﻴﺭ ﺩﻴﻨﺎﻤﻴﻜﻲ ﻤﺤﻠﻲ ﻟﺘﺴﻤﻲ ﺒﻪ ﻤﺘﻐﻴﺭ ﺩﺍﺨل ﺘﺭﻜﻴـﺏ ﻓـﻲ ﻨﻔـﺱ‬

‫ﺍﻻﺠﺭﺍﺀ:‬

‫‪Dim a As Integer‬‬
‫رﺳﺎﻟﺔ ﺧ ﻄ ﺄ '‬

‫‪Dim a as integer‬‬
‫…‬
‫…‬

‫‪Do‬‬

‫‪Loop‬‬
‫83‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻤﻊ ﺫﻟﻙ، ﻴﺴﻤﺢ ﻟﻙ ‪ Visual Basic .NET‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﻨﻔﺱ ﺍﺴﻤﺎﺀ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺍﻟﻌﺎﻤـﺔ ﺍﻭ ﻋﻠـﻰ ﻤﺴـﺘﻭﻯ‬
‫ﺍﻟﻭﺤﺩﺓ ﺍﻭ ﺤﺘﻰ ﺍﺴﻤﺎﺀ ﻤﺘﻐﻴﺭﺍﺕ ﺍﺨﺭﻯ ﻤﻌﺭﻓﺔ ﻓﻲ ﺘﺭﻜﻴﺏ ﺁﺨﺭ:‬
‫اﻓﱰض اﻧﻪ ﻣﺘﻐﲑ ﻋﻠﻰ ﻣﺴﺘﻮى اﻟﻮﺣ ﺪة او ﻋﺎ م '‬
‫‪Dim x As Integer‬‬
‫…‬
‫…‬
‫ﳑﻜﻦ ﺟﺪ ا '‬

‫ﺧﺬ راﺣ ﺘ ﻚ '‬

‫‪If x = 0 Then‬‬
‫‪Dim x As String‬‬
‫…‬
‫…‬
‫‪End If‬‬
‫‪Dim x As Long‬‬
‫…‬
‫…‬

‫‪Do‬‬

‫‪Loop‬‬

‫ﻨﻘﻁﺔ ﻫﺎﻤﺔ ﻭﺍﺨﻴﺭﺓ، ﻋﻤﺭ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻤﺴﺘﻤﺭ ﺤﺘـﻰ ﻨﻬﺎﻴـﺔ ﺍﻻﺠـﺭﺍﺀ ﻭﻟـﻴﺱ ﻨﻬﺎﻴـﺔ‬
‫ﺍﻟﺘﺭﻜﻴﺏ ﺍﻟﺫﻱ ﻋﺭﻓﺕ ﻓﻴﻪ، ﻓﺎﻟﻤﺘﻐﻴﺭ ‪ x‬ﺍﻟﺘﺎﻟﻲ ﺴﻴﺤﺘﻔﻅ ﺒﻘﻴﻤﺘﻪ ﺤﺘﻰ ﻭﺍﻥ ﺨﺭﺠﺕ ﻤﻥ ﺘﺭﻜﻴـﺏ ﺍﻟﺤﻠﻘـﺔ‬

‫‪For‬‬

‫2‪ counter‬ﺍﻟﺫﻱ ﻋﺭﻑ ﻓﻴﻬﺎ:‬

‫‪Dim counter As Integer‬‬
‫‪Dim counter2 As Integer‬‬
‫3 ‪For counter = 1 To‬‬
‫3 ‪For counter2 = 1 To‬‬
‫ﺳﻴﺴﺘ ﻤﺮ ﰲ اﻻﺣﺘﻔ ﺎظ ﺑﻘ ﻴﻤﺘ ﻪ ' ‪Dim x As Integer‬‬
‫1 + ‪x = x‬‬
‫)‪ArabicConsole.WriteLine(x‬‬

‫‪Next‬‬

‫‪Next‬‬

‫ﻤﺨﺭﺠﺎﺕ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ ﺴﺘﻜﻭﻥ:‬
‫1‬
‫2‬
‫3‬
‫4‬
‫5‬
‫6‬
‫7‬
‫8‬
‫9‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫93‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺤﻠﻴﺔ ﺍﻟﺴﺘﺎﺘﻴﻜﻴﺔ:‬
‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺤﻠﻴﺔ ﺍﻟﺴﺘﺎﺘﻴﻜﻴﺔ ‪ Static Local Variables‬ﻫﻲ ﻨﻔﺱ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺤﻠﻴﺔ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴـﺔ، ﻟـﺫﻟﻙ‬
‫ﻜل ﻤﺎ ﻗﻠﺘﻪ ﻓﻲ ﺍﻟﻔﻘﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ ﻴﻨﻁﺒﻕ ﻫﻨﺎ ﺩﻭﻥ ﺍﻱ ﺍﺨﺘﻼﻑ، ﺒﺎﺴـﺘﺜﻨﺎﺀ ﺍﻥ ﻋﻤﺭﻫـﺎ ﺍﻻﻓﺘﺭﺍﻀـﻲ ﺍﺒـﺩﻱ )ﺍﻱ‬

‫ﻴﺴﺘﻤﺭ ﺍﻟﻤﺘﻐﻴﺭ ﺍﻻﺴﺘﻜﺎﺘﻴﻜﻲ ﻤﺤﺘﻔﻅﺎ ﺒﻘﻴﻤﺘﻪ ﺤﺘﻰ ﻨﻬﺎﻴﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻭ ﻤـﻭﺕ ﺍﻟﻜـﺎﺌﻥ ﺍﻟﺘـﺎﺒﻊ ﻟـﻪ(، ﻜﻤـﺎ ﺍﻨـﻙ‬
‫ﹰ‬
‫ﺴﺘﺴﺘﺨﺩﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Static‬ﻋﻭﻀﺎ ﻋﻥ ‪ Dim‬ﻟﻠﺘﺼﺭﻴﺢ ﻋﻥ ﻤﺘﻐﻴﺭ ﺴﺘﺎﺘﻴﻜﻲ:‬
‫‪Static staticVariable As Integer‬‬

‫ﻻ ﺘﺤﺎﻭل ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﺴﺘﺎﺘﻴﻜﻴﺔ ﻜﺜﻴﺭﺍ، ﻓﻬﻲ ﺍﺒﻁﺄ ﻤـﻥ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴـﺔ، ﻜﻤـﺎ ﺍﻨﻬـﺎ‬

‫ﺘﺤﺠﺯ ﻤﺴﺎﺤﺔ ﻓﻲ ﺍﻟﺫﺍﻜﺭﺓ ﻁﻭﺍل ﻓﺘﺭﺓ ﻋﻤل ﺍﻟﺒﺭﻨﺎﻤﺞ ﺩﻭﻥ ﺃﻥ ﻴﻜﻭﻥ ﻫﻨﺎﻙ ﺤﺎﺠﺔ ﻤﺎﺴﺔ ﺇﻟﻴﻬـﺎ. ﻗـﺩ ﺘﺴـﺘﺨﺩﻡ‬
‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﺴﺘﺎﺘﻴﻜﻴﺔ ﻤﺜﻼ ﻟﻼﺤﺘﻔﺎﻅ ﺒﻘﻴﻤﺔ ﻋﺩﺍﺩ ﺍﻭ ﺘﻨﻔﻴﺫ ﺍﺠﺭﺍﺀ ﻤﺭﺓ ﻭﺍﺤﺩﺓ:‬

‫)( ‪Sub Counter‬‬
‫‪Static counter As Integer‬‬
‫1 + ‪counter = counter‬‬
‫…‬
‫…‬
‫‪End Sub‬‬
‫)( ‪Sub PrintData‬‬
‫‪Static isPrinting As Boolean‬‬
‫‪If isPrinting Then‬‬
‫‪Exit Sub‬‬
‫‪Else‬‬
‫‪isPrinting = True‬‬
‫‪End If‬‬
‫…‬
‫…‬
‫‪End Sub‬‬

‫ﺍﺨﻴﺭﺍ، ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Static‬ﻻ ﺘﻁﺒﻕ ﺍﻻ ﻋﻠﻰ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺤﻠﻴﺔ، ﻓﻼ ﺘﺤﺎﻭل ﺍﺴـﺘﺨﺩﺍﻤﻬﺎ ﻤـﻊ‬

‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻋﻠﻰ ﻤﺴﺘﻭﻯ ﺍﻟﻭﺤﺩﺓ ﺍﻭ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﻤﺔ ﻓﻬﻲ ﺴﺘﺎﺘﻴﻜﻴﺔ ﺒﻁﺒﻴﻌﺘﻬﺎ.‬
‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻋﻠﻰ ﻤﺴﺘﻭﻯ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﻤﺔ:‬

‫ﻗﺩ ﺘﻭﺩ ﻤﻥ ﺍﻻﺠﺭﺍﺀﺍﺕ ﺍﻟﻤﺨﺘﻠﻔﺔ ﺍﻟﺘﺎﺒﻌﺔ ﻟﻭﺤﺩﺓ ﺒﺭﻤﺠﻴﺔ ﻤﻌﻴﻨـﺔ ﻤﺸـﺎﺭﻜﺔ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﻓﻴﻤـﺎ ﺒﻴﻨﻬـﺎ، ﻴﻤﻜﻨـﻙ‬
‫‪ Visual Basic .NET‬ﻤﻥ ﻋﻤل ﺫﻟﻙ ﻋﻥ ﻁﺭﻴﻕ ﺘﺼﺭﻴﺢ ﻤﺘﻐﻴﺭﺍﺕ ﻋﻠـﻰ ﻤﺴـﺘﻭﻯ ﺍﻟﻭﺤـﺩﺓ ‪Module‬‬

‫‪ ،Level Variables‬ﻭﺒﻬﺫﺍ ﻴﻜﻭﻥ ﻤﺩﻯ ﻫﺫﻩ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺸﺎﻤﻼ ﻟﺠﻤﻴﻊ ﺍﺠﺭﺍﺀﺍﺕ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴـﺔ. ﺍﺴـﺘﺨﺩﻡ‬
‫ﹰ‬
‫ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Private‬ﺍﻭ ‪ Dim‬ﻟﺘﻌﺭﻴﻑ ﻤﺘﻐﻴﺭ ﻋﻠﻰ ﻤﺴﺘﻭﻯ ﺍﻟﻭﺤﺩﺓ ﺸﺭﻴﻁﺔ ﺍﻥ ﻴـﺘﻡ ﺍﻟﺘﺼـﺭﻴﺢ ﻋـﻥ‬
‫ﺍﻟﻤﺘﻐﻴﺭ ﺨﺎﺭﺝ ﺍﻻﺠﺭﺍﺀﺍﺕ:‬
‫04‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬
‫1‪Module Module‬‬
‫ﻣﺘﻐﲑات ﻋﻠﻰ ﻣ ﺴﺘﻮى اﻟﻮﺣﺪ ة '‬
‫‪Dim x As Integer‬‬
‫‪Private y As Integer‬‬
‫)(‪Sub Main‬‬
‫05 = ‪x‬‬
‫…‬
‫‪End Sub‬‬
‫)( ‪Sub Test‬‬
‫01 = ‪y‬‬
‫…‬
‫‪End Sub‬‬
‫‪End Module‬‬

‫ﺍﻤﺎ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﻤﺔ ‪ Global Variables‬ﻓﻤﺩﺍﻫﺎ ﻴﺸﻤل ﺠﻤﻴﻊ ﺸﻭﺍﺭﻉ ﻭﺍﻭﺩﻴﺔ ﻭﻤﻠﻔﺎﺕ ﺍﻟﺒﺭﻨـﺎﻤﺞ،‬
‫ﻭﻟﻴﺴﺕ ﻤﺤﺼﻭﺭﺓ ﻟﻭﺤﺩﺓ ﺒﺭﻤﺠﻴﺔ ﻤﻌﻴﻨﺔ. ﺍﺴﺘﺨﺩﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Public‬ﻟﺘﻌﺭﻴﻑ ﻤﺘﻐﻴﺭ ﻋﺎﻡ:‬

‫ﻣﺘﻐﲑ ﻋﺎ م '‬

‫1‪Module Module‬‬
‫‪Public x As Integer‬‬
‫)(‪Sub Main‬‬
‫5 = ‪x‬‬
‫…‬
‫‪End Sub‬‬
‫‪End Module‬‬

‫ﳝﻜﻦ ا ﻟﻮﺻﻮل اﱃ ا ﳌﺘﻐ ﲑ '‬

‫وﺣﺪة ﺑﺮﳎ ﻴﺔ اﺧ ﺮ ى '‬
‫2‪Module Module‬‬
‫)(‪Sub Test‬‬
‫1 = ‪x‬‬
‫…‬
‫‪End Sub‬‬
‫‪End Module‬‬

‫ﻣﻼﺣﻈﺔ‬
‫ﻳﻤﻜﻨﻚ اﻳ ﻀﺎ اﺳﺘﺨﺪام اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ Friend‬ﻟﺘﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ ﻋﺎم، وﻟﻜﻨﻬﺎ‬
‫ﺗﺨﺘ ﻠﻒ ﻋﻦ اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ Public‬ﻓﻲ ﻗﺎﺑﻠﻴﺔ اﻟﻮ ﺻﻮل اﻟﻰ اﻟﻤﺘﻐﻴﺮ ﻣﻦ‬
‫ﻣﺸﺮوع ﺧﺎرﺟﻲ. ﺣﻴﺚ ﺗﺤ ﺼﺮ ‪ Friend‬ﻣﺪى اﻟﻤﺘﻐﻴﺮ ﻋﻠﻰ اﻟﻤﺸﺮوع اﻟﺤﺎﻟﻲ‬
‫ﻓﻘﻂ.‬

‫ﻭﻜﻤﻌﻴﺎﺭ ﻟﻠﺘﺴﻤﻴﺔ، ﺘﻘﺘﺭﺡ ﻋﻠﻴﻙ ﻤﺴـﺘﻨﺩﺍﺕ ‪ .NET‬ﺍﺴـﺘﺨﺩﺍﻡ ﺍﺴـﻠﻭﺏ ‪ PascalCase‬ﻋﻨـﺩ ﺘﺴـﻤﻴﺔ‬
‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﻤﺔ ﻭﺍﻻﺴﻠﻭﺏ ‪ smallCase‬ﻟﻠﻤﺘﻐﻴﺭﺍﺕ ﻋﻠﻰ ﻤﺴﺘﻭﻯ ﺍﻟﻭﺤﺩﺓ:‬
‫ﻣﺘﻐﲑات ﻋ ﺎﻣ ﺔ '‬

‫‪Public ProgrammerName As String‬‬
‫‪Friend ClientAge As Integer‬‬

‫ﻣﺘﻐﲑات ﻋ ﻠﻰ ﻣﺴ ﺘﻮى ا ﻟﻮﺣﺪ ة '‬

‫‪Dim programmerName As String‬‬
‫‪Private clientAge As Integer‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫14‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺍﺨﻴﺭﺍ، ﻋﻤﺭ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻋﻠﻰ ﻤﺴﺘﻭﻯ ﺍﻟﻭﺤﺩﺓ ﺍﻭ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﻤﺔ ﻤﺴﺘﻤﺭ ﺤﺘـﻰ ﻨﻬﺎﻴـﺔ ﺍﻟﺒﺭﻨـﺎﻤﺞ ﺍﻭ‬
‫ﺍﻟﻜﺎﺌﻥ ﺍﻟﺘﺎﺒﻊ ﺍﻟﺫﻱ ﺼﺭﺤﺕ ﻓﻴﻪ.‬

‫اﻧﻮاع اﻟﺒﻴﺎﻧﺎت‬
‫ﻴﺒﺩﻭ ﺍﻥ ﺍﻟﻭﻗﺕ ﻗﺩ ﺤﺎﻥ ﻷﺨﺫ ﺠﻭﻟﺔ ﺘﻌﺭﻴﻔﻴﺔ ﺤﻭل ﺍﻨﻭﺍﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﺨﺘﻠﻔـﺔ ﺍﻟﺘـﻲ ﺘﺴـﺘﻁﻴﻊ ﺍﺴـﺘﺨﺩﺍﻤﻬﺎ ﻓـﻲ‬
‫ﺒﺭﺍﻤﺠﻙ، ﻭﻟﻜﻥ ﺩﻋﻨﻲ ﺍﻭﻀﺢ ﻟﻙ ﻨﻅﺭﺘﻲ ﺍﻟﺸﺨﺼﻴﺔ ﺤﻭل ﻫﺫﻩ ﺍﻟﻔﻘﺭﺓ:‬

‫ﺍﻨﻭﺍﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ )ﻜـ ‪.... Date ،Long ،Integer ،String‬ﺍﻟﺦ( ﻻ ﺘﺘﺒﻊ –ﺘﻘﻨﻴـﺎ - ﻟﻠﻐـﺔ ﺍﻟﺒﺭﻤﺠـﺔ‬
‫‪ ،Visual Basic .NET‬ﻓﻬﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﻓﺌﺎﺕ ‪ Classes‬ﻭﺘﺭﻜﻴﺒﺎﺕ ‪ Structures‬ﻋﺭﻓـﺕ ﻓـﻲ ﻤﻜﺘﺒـﺔ‬

‫ﻓﺌﺎﺕ ‪) BCL‬ﺍﻟﺘﺎﺒﻌﺔ ﻻﻁﺎﺭ ﻋﻤل ‪ .NET Framework‬ﻭﺍﻟﺘﻲ ﺘﺤـﺩﺜﺕ ﻋﻨﻬـﺎ ﻓـﻲ ﺍﻟﻔﺼـل ﺍﻟﺴـﺎﺒﻕ(،‬
‫ﻭﺒﻌﺒﺎﺭﺓ ﺃﺨﺭﻯ: ﻜل ﺸﺊ ﺘﺭﺍﻩ ﻓﻲ ﺸﻴﻔﺭﺍﺘﻙ ﻋﺒـﺎﺭﺓ ﻋـﻥ ﻜـﺎﺌﻥ ‪ ،Object‬ﻓـﺎﻥ ﻜﻨـﺕ ﻤـﻥ ﺍﻟﻤﺒـﺭﻤﺠﻴﻥ‬
‫ﺍﻟﻤﺨﻀﺭﻤﻴﻥ ﻋﻠﻴﻙ ﺍﻥ ﺘﻌﻠﻡ ﻋﻠﻡ ﺍﻟﻴﻘﻴﻥ ﺍﻥ ﺠﻤﻴﻊ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﺘﻲ ﺘﺼﺭﺡ ﻋﻨﻬﺎ ﻭﺘﺴـﺘﺨﺩﻤﻬﺎ ﻓـﻲ ﺒﺭﺍﻤﺠـﻙ،‬
‫ﻤﺎﻫﻲ ﺍﻻ ﻜﺎﺌﻨﺎﺕ ﻤﻨﺸﺄﺓ ﻤﻥ ﻓﺌﺎﺕ ﺍﻭ ﺘﺭﻜﻴﺒﺎﺕ ﻤﻌﺭﻓﺔ ﻤﺴﺒﻘﺎ. ﻓﺤﺘﻰ ﺍﺒﺴﻁ ﺍﻨـﻭﺍﻉ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﻤﺜـل ‪،Byte‬‬
‫ﹰ‬
‫ﻓﻬﻭ ﻋﺒﺎﺭﺓ ﻋﻥ ﻜﺎﺌﻥ ﻟﻪ ﻁﺭﻕ ﻭﺨﺼﺎﺌﺹ ﺘﺎﺒﻌﻪ ﻟﻪ. ﻭﺒﻤﺎ ﺍﻨﻨﺎ ﻤﺎ ﺯﻟﻨﺎ ﻓﻲ ﺒﺩﺍﻴﺔ ﺘﻌﻠﻡ ﺍﺴﺎﺴﻴﺎﺕ ﻟﻐـﺔ ﺍﻟﺒﺭﻤﺠـﺔ‬

‫‪ ،Visual Basic .NET‬ﻓﻼ ﺍﻋﺘﻘﺩ ﺍﻨﻪ ﻤﻥ ﺍﻟﻤﻨﺎﺴﺏ –ﺤﺎﻟﻴﺎ ﻋﻠﻰ ﺍﻷﻗل - ﺍﻟﺘﺤﺩﺙ ﻋﻥ ﻫـﺫﻩ ﺍﻻﻨـﻭﺍﻉ ﻗﺒـل‬
‫ﺍﺴﺘﻴﻌﺎﺏ ﺍﻟﻜﺎﺌﻨﺎﺕ ﻭﺍﻟﻔﺌﺎﺕ )ﻭﻫﻭ ﻤﻭﻀﻭﻉ ﺍﻟﻔﺼل ﺍﻟﺜﺎﻟﺙ ﺍﻟﻔﺌﺎﺕ ﻭﺍﻟﻜﺎﺌﻨﺎﺕ(، ﻟـﺫﻟﻙ ﻜـﺎﻥ ﻗـﺭﺍﺭﻱ ﺍﻟﻨﻬـﺎﺌﻲ‬
‫ﻫﻭ ﺘﺄﺠﻴل ﺘﻔﺼﻴل ﻫﺫﻩ ﺍﻻﻨﻭﺍﻉ ﺍﻟﻰ ﺍﻟﻔﺼل ﺍﻟﺴﺎﺩﺱ ﺍﻟﻔﺌﺎﺕ ﺍﻷﺴﺎﺴﻴﺔ. ﻭﺇﻟﻲ ﺍﻥ ﻨﻠﺘﻘﻲ ﻫﻨـﺎﻙ، ﻴﻌـﺭﺽ ﻟـﻙ‬

‫ﺍﻟﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ﻤﻠﺨﺹ ﺴﺭﻴﻊ ﻻﻨﻭﺍﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻻﻭﻟﻴﺔ ‪ Primitive Data Types‬ﺍﻟﺘـﻲ ﻴـﺩﻋﻤﻬﺎ ‪Visual‬‬
‫‪:Basic .NET‬‬
‫ﺍﻟﻨﻭﻉ‬
‫‪Boolean‬‬

‫ﺍﻟﺤﺠ ﻡ‬

‫ﻤﺠﺎل ﺍﻟﻘﻴﻤﺔ‬

‫2 ﺒﺎﻴﺕ‬

‫‪) True‬ﺼﺢ( ﺍﻭ ‪) False‬ﺨﻁﺄ(.‬

‫‪Byte‬‬

‫1 ﺒﺎﻴﺕ‬

‫ﻋﺩﺩ ﺼﺤﻴﺢ ﻤﻥ 0 ﺍﻟﻰ 552 .‬

‫‪Char‬‬

‫2 ﺒﺎﻴﺕ‬

‫ﺤﺭﻑ ﻭﺍﺤﺩ ﻤﻥ ﻨﻭﻉ ‪.UNICODE‬‬

‫‪Date‬‬

‫8 ﺒﺎﻴﺕ‬

‫‪Decimal‬‬

‫61 ﺒﺎﻴﺕ‬

‫ﻭﻗﺕ ﻤﻥ ﺍﻟﺴﺎﻋﺔ 00:00:0 ﺍﻟﻰ ﺍﻟﺴﺎﻋﺔ 95:95:11، ﻜﻤﺎ‬
‫ﻴﺸﻤل ﺘﺎﺭﻴﺦ ﻤﻥ ﻴﻭﻡ 1 ﻴﻨﺎﻴﺭ ﻟﻌﺎﻡ 1000 ﺍﻟﻰ 13 ﺩﻴﺴ ﻤﺒﺭ‬
‫ﻟﻌﺎﻡ 9999 .‬

‫ﻋﺩﺩ ﺼﺤﻴﺢ ﻤﻥ 0 ﺍﻟﻰ‬
‫±533,059,345,395,733,462,415,261,822,97‬
‫ﺍﻭ ﻋﺸﺭﻱ ﻤﻥ 0 ﺍﻟﻰ‬

‫±5330593453957334624152618229.7‬
‫24‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺍﻟﻨﻭﻉ‬
‫‪Double‬‬

‫ﺍﻟﺤﺠ ﻡ‬

‫ﻤﺠﺎل ﺍﻟﻘﻴﻤﺔ‬

‫8 ﺒﺎﻴﺕ‬

‫ﻋﺩﺩ ﻋﺸﺭﻱ ﻤﻥ 803+‪ 1.79769313486231570E‬ﺍﻟﻰ‬

‫‪Integer‬‬

‫4 ﺒﺎﻴﺕ‬

‫‪Long‬‬

‫8 ﺒﺎﻴﺕ‬

‫‪Object‬‬

‫4 ﺒﺎﻴﺕ‬

‫ﺠﻤﻴﻊ ﺍﻟﻘﻴﻡ ﻭﺍﻻﻨﻭﺍﻉ ﻴﻤﻜﻥ ﺤﻔﻅﻬﺎ ﻫﻨﺎ .‬

‫‪Short‬‬

‫2 ﺒﺎﻴﺕ‬

‫ﻋﺩﺩ ﺼﺤﻴﺢ ﻤﻥ – 867,23 ﺍﻟﻰ 767,23.‬

‫423-‪ 4.94065645841246544E‬ﺒﺎﻟﻨﺴﺒﺔ ﻟﻼﻋﺩﺍﺩ ﺍﻟﺴﺎﻟﺒﺔ.‬
‫ﻭﻤﻥ‬

‫423-‪ 4.94065645841246544E‬ﺍﻟﻰ‬
‫803+‪ 1.79769313486231570E‬ﺒﺎﻟﻨﺴﺒﺔ ﻟﻼﻋﺩﺍﺩ‬

‫ﺍﻟﻤﻭﺠﺒﻪ .‬

‫ﻋﺩﺩ ﺼﺤﻴﺢ ﻤﻥ – 846,384,741,2 ﺍﻟﻰ‬
‫746,384,741,2.‬

‫ﻋﺩﺩ ﺼﺤﻴﺢ ﻤﻥ - 808,577,458,630,273,322,9 ﺍﻟﻰ‬

‫708,577,458,630,273,322,9.‬

‫‪Single‬‬

‫4 ﺒﺎﻴﺕ‬

‫‪String‬‬

‫01 + )2 * ﻋﺩﺩ‬

‫ﻋﺩﺩ ﻋﺸﺭﻱ ﻤﻥ 83+‪ 3.4028235E‬ﺍﻟﻰ 54-‪1.401298E‬‬

‫ﺒﺎﻟﻨﺴﺒﺔ ﻟﻼﻋﺩﺍﺩ ﺍﻟﺴﺎﻟﺒﺔ. ﻭﻤﻥ 54-‪ 1.401298E‬ﺍﻟﻰ‬
‫83+‪ 3.4028235E‬ﺒﺎﻟﻨﺴﺒﺔ ﻟﻼﻋﺩﺍﺩ ﺍﻟﻤﻭﺠﺒﻪ .‬

‫ﻤﻥ 0 ﺍﻟﻰ 2 ﻤﻠﻴﺎﺭ ﺤﺭﻑ ﻤﻥ ﻨﻭﻉ ‪.UNICODE‬‬

‫ﺍﻟﺤﺭﻭﻑ( ﺒﺎﻴﺕ‬
‫ﻋﻨﺩﻤﺎ ﺘﻤﻌﻥ ﺍﻟﻨﻅﺭ ﻓﻲ ﺍﻟﺠﺩﻭل ﺍﻟﺴﺎﺒﻕ، ﺴﺘﻼﺤﻅ ﻭﺠﻭﺩ ﻨﻭﻋﻴﻥ ﻤﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺤﺭ ﻓﻴـﺔ ﻫﻤـﺎ ‪ Char‬ﻭ‬
‫‪ .String‬ﺒﺎﻟﻨﺴﺒﺔ ﻟﻠﻨﻭﻉ ﺍﻻﻭل ﻓﻬﻭ ﻴﻤﺜل ﺤﺭﻑ ﻭﺍﺤﺩ ﻓﻘﻁ ﻤﻥ ﺤﺭﻭﻑ ‪ ،Unicode‬ﻟﺫﻟﻙ ﻓـﺎﻟﻤﺘﻐﻴﺭﺍﺕ ﻤـﻥ‬

‫ﺍﻟﻨﻭﻉ ‪ Char‬ﻻﻴﻤﻜﻥ ﺍﻥ ﺘﺤﻤل ﻗﻴﻤﺔ ﺤﺭﻓﻴﻪ ﺘﺯﻴﺩ ﻋﻥ ﺤﺭﻑ ﻭﺍﺤﺩ، ﻜﻤﺎ ﻴﺸﺭﻁ ﺍﺴﺘﺨﺩﺍﻡ ﺤـﺭﻑ ﺍﻟـﺫﻴل "‪"c‬‬
‫ﺤﺘﻰ ﺘﻤﻴﺯ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺤﺭﻓﻴﺔ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Char‬ﻋﻥ ﻗﻴﻤﺔ ﺴﻠﺴﻠﺔ ﺍﻟﺤﺭﻭﻑ ﻤﻥ ﺍﻟﻨﻭﻉ ‪:String‬‬

‫‪Dim A As Char‬‬
‫رﺳﺎﻟﺔ ﺧﻄ ﺄ هﻨ ﺎ '‬

‫‪"c‬ت" = ‪A‬‬
‫‪"c‬ﺗﺮآ ﻲ" = ‪A‬‬

‫ﻗﺩ ﺘﺴﺘﻐﺭﺏ ﻤﺩﻯ ﺍﻟﺠﺩﻭﻯ ﻤﻥ ﺍﻻﻋﺘﻤﺎﺩ ﻋﻠﻰ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻤﻥ ﻨﻭﻉ ‪ Char‬ﺒـﺩﻻ ﻤـﻥ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﻤـﻥ‬

‫ﻨﻭﻉ ‪ String‬ﺭﻏﻡ ﺍﻤﻜﺎﻨﻴﺎﺘﻬﺎ ﺍﻟﻤﺤﺩﻭﺩﺓ، ﺍﻟﺴﺒﺏ ﺒﺒﺴﺎﻁﺔ ﺍﻟﺴـﺭﻋﺔ ﻓـﻲ ﺍﻟﺘﻨﻔﻴـﺫ ﻭﺍﻻﻗﺘﺼـﺎﺩ ﻓـﻲ ﺍﺴـﺘﻬﻼﻙ‬
‫ﻤﺼﺎﺩﺭ ﺍﻟﻨﻅﺎﻡ. ﺤﻴﺙ ﺃﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻤﻥ ﻨﻭﻉ ‪ Char‬ﻫﻲ ﻤﺘﻐﻴﺭﺍﺕ ﻤﻥ ﺍﻟﻨـﻭﻉ ﺫﺍﺕ ﺍﻟﻘﻴﻤـﺔ ‪Value Type‬‬
‫‪ Variables‬ﺒﻴﻨﻤـﺎ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﻤـﻥ ﺍﻟﻨـﻭﻉ ‪ String‬ﻫـﻲ ﻤﺘﻐﻴـﺭﺍﺕ ﻤﺭﺠﻌﻴـﺔ ‪Reference Type‬‬
‫‪ .Variables‬ﺍﻟﻔﺭﻭﻕ ﺒﻴﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ ﻫﻭ ﻤﻭﻀﻭﻉ ﺍﻟﻔﻘﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ.‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫34‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ:‬
‫ﺘﻭﺠﺩ ﻤﺴﺎﺌل ﺘﻘﻨﻴﺔ ﺒﺤﺘﺔ ﺘﻌﺘﺒﺭ ﻓﻲ ﻏﺎﻴﺔ ﺍﻻﻫﻤﻴﺔ ﺘﺘﻌﻠﻕ ﺒﺎﻟﻤﺘﻐﻴﺭﺍﺕ، ﺤﻴﺙ ﺍﻨﻲ ﺫﻜﺭﺕ -ﻓﻲ ﺒﺩﺍﻴﺔ ﻫـﺫﺍ ﺍﻟﻘﺴـﻡ‬
‫ﻤﻥ ﺍﻟﻔﺼل - ﺍﻥ ﺍﻟﺒﻨﻴﺔ ﺍﻟﺘﺤﺘﻴﺔ ﻟﻠﻤﺘﻐﻴﺭﺍﺕ ﻗﺩ ﺘﻐﻴﺭﺕ ﺘﻐﻴﺭﺍ ﺠﺫﺭﻴﺎ ﻋﻤﺎ ﻜﺎﻨـﺕ ﻋﻠﻴـﻪ ﻓـﻲ ﻟﻐـﺎﺕ ﺍﻟﺒﺭﻤﺠـﺔ‬
‫ﹰ‬
‫ﹰ‬

‫ﺍﻟﺴﺎﺒﻘﺔ، ﺍﺫ ﺍﻥ ﺍﻟﻘﻀﻴﺔ ﺍﺒﻌﺩ ﻤﻥ ﺃﻥ ﺘﻜﻭﻥ ﻤﺠﺭﺩ ﻤﻨﻁﻘﺔ ﻤﺤﺠﻭﺯﺓ ﻓـﻲ ﺍﻟـﺫﺍﻜﺭﺓ ﺘﺤﻔـﻅ ﺒﻬـﺎ ﻗﻴﻤـﺔ ﻟﺘﻤﺜـل‬
‫ﺍﻟﻤﺘﻐﻴﺭ، ﻓﻜل ﺸﻲﺀ ﺘﺭﺍﻩ ﻓﻲ ‪ Visual Basic .NET‬ﻫﻭ ﻜﺎﺌﻥ ‪ Object‬ﻜﻤﺎ ﺍﺘﻔﻘﻨﺎ ﺴـﺎﺒﻘﺎ. ﻭﻟﻜـﻥ ﻋﻠﻴـﻙ‬
‫ﻤﻌﺭﻓﺔ ﺍﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ –ﺍﻭ ﺍﻨﻭﺍﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺼﻔﺔ ﻋﺎﻤﺔ - ﻓﻲ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠـﺔ ‪ Visual Basic .NET‬ﺘﻨﻘﺴـﻡ‬

‫ﺍﻟﻰ ﻗﺴﻤﻴﻥ ﺭﺌﻴﺴﻴﻥ ﻤﻬﻤﺎ ﺍﺨﺘﻠﻔﺕ ﺍﻨﻭﺍﻋﻬﺎ ﻫﻤﺎ: ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠ ﻌﻴـﺔ ‪Reference Type Variables‬‬
‫ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ ‪.Value Type Variables‬‬

‫ﺴﺄﺒﺩﺍ ﻤﻌﻙ ﺒﺎﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ ‪ ،Value Type Variables‬ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﻤﺸـﺘﻕ‬
‫ﻭﺭﺍﺜﻴﺎ ﻤﻥ ﺍﻟﻔﺌﺔ ‪) System.ValueType‬ﺍﻟﻭﺭﺍﺜﺔ ﻭﺍﻻﺸﺘﻘﺎﻕ ﺍﻟﻭﺭﺍﺜﻲ ﻤﻭﻀﻭﻉ ﺍﻟﻔﺼل ﺍﻟﺭﺍﺒـﻊ ﺍﻟﻭﺭﺍﺜـﺔ(.‬

‫ﺘﻘﻨﻴﺎ، ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺸﺒﻴﻪ ﺒﻔﻜﺭﺓ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﻟﻐـﺎﺕ ﺍﻟﺒﺭﻤﺠـﺔ ﺍﻟﺴـﺎﺒﻘﺔ، ﺤﻴـﺙ ﺍﻥ‬
‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺘﺤﻔﻅ ﻗﻴﻤﻬﺎ ﻓﻲ ﻗﺴﻡ ﻤﻥ ﺫﺍﻜﺭﺓ ﺍﻟﺒﺭﻨﺎﻤﺞ ) ﻗﺩ ﺘﻜﻭﻥ ‪ Stack‬ﻓﻲ ﻤﻌﻅﻡ ﺍﻻﺤﻭﺍل(، ﻭﺴـﺘﻤﺤﻰ ﻤـﻥ‬
‫ﺍﻟﺫﺍﻜﺭﺓ ﻤﺒﺎﺸﺭﺓ ﺒﻌﺩ ﻨﻬﺎﻴﺔ ﻋﻤﺭ ﺍﻟﻤﺘﻐﻴـﺭ. ﺠﻤﻴـﻊ ﺍﻟﺒﻴﺎﻨـﺎﺕ ﺍﻟﻌﺩﺩﻴـﺔ ‪ ،Numbers‬ﻭﺍﻟﺒﻴﺎﻨـﺎﺕ ﻤـﻥ ﺍﻟﻨـﻭﻉ‬
‫‪ ،Char ،Boolean‬ﻭ ‪ ،Date‬ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﻌﺭﻓﺔ ﻤﻥ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ‪ Structures‬ﺍﻭ ‪ Enums‬ﻫﻲ ﺒﻴﺎﻨـﺎﺕ‬
‫ﻤﻥ ﺍﻟﻨﻭﻉ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ ‪.Value Type‬‬

‫ﺍﻤﺎ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ ‪ ،Reference Type‬ﻓﻴﻭﺠﺩ ﺍﻟﻜﺜﻴﺭ ﻻﺨﺒﺭﻙ ﺒﻪ ﻋﻨﻬﺎ ﻻﺤﻘﺎ، ﻭﻟﻜﻥ ﻜـل ﻤـﺎ‬

‫ﺍﺭﻴﺩ ﻤﻨﻙ ﺍﻥ ﺘﻌﻠﻤﻪ ﻋﻨﻬﺎ ﻓﻲ ﺍﻟﻭﻗﺕ ﺍﻟﺤﺎﻟﻲ ﻫﻭ ﺍﻥ ﻗﻴﻤﺔ ﺍﻟﻤﺘﻐﻴﺭ )ﻴﺴﻤﻰ ﻤﺅﺸﺭ ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ( ﻴـﺘﻡ ﺤﻔﻅـﻪ‬
‫ﻜﻤﺎ ﺘﺤﻔﻅ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ، ﺒﻴﻨﻤﺎ ﺘﺤﻔﻅ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺤﻘﻴﻘﺔ ﻟﻠﻜﺎﺌﻥ ﻓﻲ ﻗﺴﻡ ﺨﺎﺹ ﻤـﻥ ﺫﺍﻜـﺭﺓ ﺍﻟﺒﺭﻨـﺎﻤﺞ‬

‫ﻴﺴﻤﻰ ‪ ،Managed Heap‬ﻭﻓﻲ ﺍﻟﺤﻘﻴﻘﺔ ﻻ ﺘﺘﻡ ﻋﻤﻠﻴﺔ ﺍﺯﺍﻟﺔ ﻗﻴﻤﻬﺎ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ﻤﺒﺎﺸﺭﺓ ﺒﻌﺩ ﻨﻬﺎﻴﺔ ﻋﻤﺭﻫـﺎ‬
‫ﺍﻻﻓﺘﺭﺍﻀﻲ، ﻓﻬﻲ ﺘﺘﻁﻠﺏ ﻋﻤﻠﻴﺔ ﺘﺴﻤﻰ ﺍﻓﺭﺍﻍ ﺍﻟﻤﺼﺎﺩﺭ ﻋﻥ ﻁﺭﻴـﻕ ﻤﺠﻤﻭﻋـﺔ ‪Garbage Collection‬‬
‫ﻤﻘﺩﻤﺔ ﻤﻥ ﺍﻁﺎﺭ ﻋﻤل ‪ .NET‬ﻓﻠﻭ ﻜﺎﻥ ﻟﺩﻴﻨﺎ ﻫﺫﻴﻥ ﺍﻟﻤﺘﻐﻴﺭﻴﻥ:‬
‫ﻣﺘﻐﲑ ﻣﺮﺟ ﻌ ﻲ '‬
‫ﻣﺘﻐﲑ ذا ﻗﻴﻤ ﺔ '‬

‫"ﺗﺮآﻲ اﻟﻌ ﺴﲑ ي" = ‪Dim Name As String‬‬
‫99 = ‪Dim Age As Integer‬‬

‫ﻴﻤﻜﻨﻨﺎ ﺘﺨﻴل ﻤﻭﺍﻗﻌﻬﻤﺎ ﺒﺎﻟﺫﺍﻜﺭﺓ ﻜﻤﺎ ﻓﻲ ﺍﻟﺸﻜل ﺍﻟﺘﺎﻟﻲ:‬

‫ﺸﻜل 2 -3: ﺍﻤﺎﻜﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ ﻓﻲ ﺍﻟﺫﺍﻜﺭﺓ.‬
‫44‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫اﻧﻈﺮ اﻳﻀﺎ‬
‫ﻟﻲ ﻋﻮدة اﺧﺮى ﺣﻮل اﻟﻤﺘﻐﻴﺮات ذات اﻟﻘﻴﻤﺔ ﻓﻲ اﻟﻔ ﺼﻞ اﻟﺴﺎدس اﻟﻔﺌﺎت‬
‫اﻻﺳﺎﺳﻴﺔ ، ﺑﻴﻨﻤﺎ ﺳﻴﻜﻮن ﻟﻲ ﺣﺪﻳﺚ ﻣﻄﻮل ﻋﻦ اﻟﻤﺘﻐﻴﺮات اﻟﻤﺮﺟﻌﻴﺔ ﻓﻲ‬
‫اﻟﻔ ﺼﻞ اﻟﺜﺎﻟﺚ اﻟﻔﺌﺎت واﻟﻜﺎﺋﻨﺎت .‬

‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ ،String‬ﻭﺍﻟﻤﺼﻔﻭﻓﺎﺕ ‪ ،Arrays‬ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﻌﺭﻓﺔ ﻤﻥ ﺍﻟﻔﺌـﺎﺕ ‪Classes‬‬

‫ﺠﻤﻴﻌﻬﺎ ﻤﺘﻐﻴﺭﺍﺕ ﻤﺭﺠﻌﻴﺔ ‪.Reference Type‬‬

‫ﻤﻥ ﻤﻨﻁﻠﻕ ﺍﻟﺘﺴﻠﺴل ﺍﻟﺘﻌﻠﻴﻤﻲ ﺍﻟﺫﻱ ﺍﺘﺒﻌﻪ ﻓﻲ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ، ﻻ ﺍﺭﻴﺩ ﺍﻋﻁﺎﺌـﻙ ﺠﻤﻴـﻊ ﺍﻟﻔﺭﻭﻗـﺎﺕ ﺒـﻴﻥ‬

‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ ﻫﻨﺎ، ﺤﻴﺙ ﺍﻨﻲ ﺍﻓﻀل ﺫﻜﺭﻫﺎ ﻓﻲ ﺍﻤـﺎﻜﻥ ﻤﺘ ﻔﺭﻗـﺔ ﻤـﻥ ﻫـﺫﺍ‬
‫ﺍﻟﻜﺘﺎﺏ ﻟﻜﻲ ﺘﻨﺎﺴﺏ ﺍﻟﻔﻘﺭﺍﺕ ﺍﻟﺘﺎﺒﻌﺔ ﻟﻬﺎ، ﻭﻟﻜﻥ ﺩﻋﻨﻲ ﺍﺨﺒﺭﻙ ﻫﻨﺎ ﺒﺎﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤـﺔ ﺍﺴـﺭﻉ ﺒﻜﺜﻴـﺭ‬
‫ﻤﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ، ﻜﻤﺎ ﺍﻨﻬﺎ ﺍﻗﺘﺼﺎﺩﻴﺔ ﺠﺩﺍ ﻓﻲ ﺍﺴﺘﻬﻼﻙ ﻤﺼﺎﺩﺭ ﺍﻟﻨﻅﺎﻡ، ﻟﺫﻟﻙ ﺤﺎﻭل ﺍﻻﻋﺘﻤـﺎﺩ ﻋﻠﻴﻬـﺎ‬

‫ﻋﻭﻀﺎ ﻋﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ ﺍﻻ ﺍﻥ ﺩﻋﺘﻙ ﺍﻟﺤﺎﺠﺔ ﻟﻐﻴﺭ ﺫﻟﻙ.‬

‫اﺳﻨﺎد اﻟﻘﻴ ﻢ‬
‫ﻗﺩ ﺘﺴﺘﻐﺭﺏ ﻤﻥ ﺘﺨﺼﻴﺹ ﻓﻘﺭﺓ ﻜﺎﻤﻠﺔ ﻋﻥ ﻋﻤﻠﻴﺔ ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ ﺍﻟﻰ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ، ﺍﻻ ﺍﻨـﻙ ﺴﺘﻜﺘﺸـﻑ ﺍﻥ ﺍﻻﻤـﺭ‬
‫ﺒﺤﺎﺠﺔ ﺍﻟﻰ ﺍﻟﺘﻁﺭﻕ ﻟﺒﻌﺽ ﺍﻟﺘﻔﺎﺼﻴل ﺍﻟﺩﻗﻴﻘﺔ ﺤﻭل ﻫﺫﻩ ﺍﻟﻤﺴﺄﻟﺔ.‬

‫ﺒﺎﺩﺉ ﺫﻱ ﺒﺩﺀ، ﺍﻨﺕ ﺘﻌﻠﻡ ﻭﺍﻨﺎ ﺍﻋﻠﻡ ﺍﻨﻨﺎ ﻨﺴﺘﻁﻴﻊ ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ ﺍﻟﻰ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺒﺎﺴـﺘﺨﺩﺍﻡ ﻤﻌﺎﻤـل ﺍﺴـﻨﺎﺩ‬

‫ﺍﻟﻘﻴﻡ "="، ﻴﻤﻜﻨﻙ ﺍﺴﻨﺎﺩ ﻗﻴﻤﺔ ﻟﻠﻤﺘﻐﻴﺭ ﺒﻌﺩ ﺍﻟﺘﺼﺭﻴﺢ ﻋﻨـﻪ ﻤﺒﺎﺸـﺭﺓ، ﺍﻭ ﺍﺜﻨـﺎﺀ ﻋﻤﻠﻴـﺔ ﺍﻟﺘﺼـﺭﻴﺢ ﺒﻜـل‬

‫ﺍﻨﺴﻴﺎﺒﻴﺔ:‬

‫اﺳﻨﺎ د ﻗﻴﻤ ﺔ ﳊﻈﺔ اﻟﺘﺼ ﺮﻳ ﺢ ' 01 = ‪Dim X As Integer‬‬
‫‪Dim Y As Integer‬‬
‫‪Dim Z As Long‬‬
‫02 = ‪Y‬‬
‫03 = ‪Z‬‬

‫ﺍﻥ ﺍﺴﻨﺩﺕ ﻗﻴﻡ ﻟﻠﻤﺘﻐﻴﺭﺍﺕ ﺍﺜﻨﺎﺀ ﻋﻤﻠﻴﺔ ﺍﻟﺘﺼﺭﻴﺢ ﻻﻜﺜﺭ ﻤﻥ ﻤﺘﻐﻴﺭ ﻓﻲ ﺴﻁﺭ ﻭﺍﺤﺩ، ﻋﻠﻴﻙ ﺘﺤﺩﻴـﺩ ﻨـﻭﻉ‬

‫ﺍﻟﻤﺘﻐﻴﺭ ﻟﻜل ﺘﺼﺭﻴﺢ ﻭﺍﻻ ﺴﺘﻅﻬﺭ ﺭﺴﺎﻟﺔ ﺨﻁﺎ:‬

‫هﻨﺎ ﳑﻜ ﻦ '‬
‫03 = ‪Dim X As Integer, Y As Integer = 20, Z As Long‬‬
‫رﺳﺎﻟﺔ ﺧﻄ ﺄ '‬
‫03 = ‪Dim X, Y As Integer = 20, Z As Long‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫54‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻟﺴﺕ ﺒﺤﺎﺠﺔ ﻻﺨﺒﺎﺭﻙ ﺍﻨﻙ ﺍﻟﻤﺴﺅﻭل ﺍﻻﻭل ﻭﺍﻻﺨﻴﺭ ﻋﻥ ﻤﺠﺎل ﺍﻟﻘﻴﻡ ﺍﻟﺘﻲ ﺘﺴـﻨﺩﻫﺎ ﺍﻟـﻰ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ،‬
‫ﻭﺍﻥ ﺍﻀﻔﺕ ﻗﻴﻤﺔ ﺨﺎﺭﺝ ﻨﻁﺎﻕ ﻤﺠﺎل ﺍﻟﻘﻴﻡ ﺍﻟﻤﺴﻤﻭﺡ ﺒﻪ ﻟﻨﻭﻉ ﻤﻌﻴﻥ ﻤﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ، ﺴـﺘﻅﻬﺭ ﺭﺴـﺎﻟﺔ ﺨﻁـﺄ‬
‫ﻭﻗﺕ ﺍﻟﺘﻨﻔﻴﺫ:‬

‫رﺳﺎﻟﺔ ﺧﻄ ﺄ '‬
‫652 = ‪Dim X As Byte‬‬

‫ﺍﻟﻤﺯﻴﺩ ﺍﻴﻀﺎ، ﻴﻭﻓﺭ ﻟﻙ ‪ Visual Basic .NET‬ﻤﻌﺎﻤﻼﺕ ﺍﻀﺎﻓﻴﺔ ﻻﺴﻨﺎﺩ ﺍﻟﻘـﻴﻡ ﺍﻟـﻰ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ‬

‫ﺘﻌﺘﺒﺭ ﺍﺨﺘﺼﺎﺭ ﻟﻌﻤﻠﻴﺎﺕ ﺭﻴﺎﻀﻴﺔ ﺸﺎﺌﻌﺔ ﺘﻭﻀﺤﻬﺎ ﻟﻙ ﻫﺫﻩ ﺍﻟﺸﻴﻔﺭﺓ:‬

‫5 + 5 = ‪Dim X As Integer‬‬
‫1‬
‫2‬
‫3‬
‫6‬
‫2‬

‫+‬
‫‬‫*‬
‫‬
‫^‬

‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬

‫=‬
‫=‬
‫=‬
‫=‬
‫=‬

‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬

‫'‬
‫'‬
‫'‬
‫'‬
‫'‬

‫1‬
‫2‬
‫3‬
‫6‬
‫2‬

‫=+‬
‫=-‬
‫=*‬
‫=‬
‫=^‬

‫‪X‬‬
‫‪X‬‬
‫‪X‬‬
‫‪X‬‬
‫‪X‬‬

‫ﻤﻊ ﺍﻟﻌﻠﻡ ﺍﻥ ﺍﻟﻤﻌﺎﻤﻼﺕ ﺍﻟﺴﺎﺒﻘﺔ ﻻ ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﺍﺜﻨﺎﺀ ﻋﻤﻠﻴﺔ ﺍﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺍﻟﻤﺘﻐﻴﺭ:‬
‫ﻟﻦ ﻳﺴﻤﺢ ﻟ ﻚ ‪ Visual Basic .NET‬ﺑﻜﺘﺎﺑﺔ ا ﻟﺸﻴﻔﺮ ة '‬
‫ﺑﺎﻟﺸﻜﻞ ا ﻟﺘﺎﱄ ﺣﱴ ﻟﻮ ﺗﻮﺳﻂ ﺑﻴﻞ ﺟﻴﺘ ﺲ '‬
‫01 =+ ‪Dim X As Integer‬‬
‫02 =^ ‪Dim Y As Long‬‬

‫ﺩﻋﻨﻲ ﺍﻭﻀﺢ ﻟﻙ ﻗﻀﻴﺔ ﺘﻘﻨﻴﺔ ﺘﺘﻌﻠﻕ ﺒﺎﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ ﺤﻴﺙ ﺘﺒﻴﻥ ﻟﻨﺎ ﺍﺤـﺩ ﺍﻟﻔـﺭﻭﻕ ﺒـﻴﻥ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺫﺍﺕ‬
‫ﺍﻟﻘﻴﻤﺔ ‪ Value Type‬ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ ‪ .Reference Type‬ﻋﻤﻠﻴﺔ ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ ﺒـﻴﻥ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺫﺍﺕ‬

‫ﺍﻟﻘﻴﻤﺔ ﺘﻘﻭﻡ ﺒﻨﺴﺦ ﻓﻌﻠﻲ ﻟﻠﻤﺘﻐﻴﺭﺍﺕ ﻟﻴﺴﺘﻘل ﻜل ﻤﺘﻐﻴﺭ ﺒﻘﻴﻤﺘﻪ، ﺍﻤﺎ ﺍﺴﻨﺎﺩ ﺍﻟﻘـﻴﻡ ﺒـﻴﻥ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴـﺔ،‬
‫ﻓﻬﻲ ﻻ ﺘﺅﺩﻱ ﺇﻟﻰ ﻨﺴﺦ ﻗﻴﻡ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ، ﺒل ﻜل ﻤﺎ ﺘﻘﻭﻡ ﺒﻪ ﻫﻭ ﻨﺴﺦ ﺍﻟﻤﺅﺸﺭﺍﺕ ﻟﺘﺸـﻴﺭ ﺍﻟـﻰ ﻨﻔـﺱ ﺍﻟﻜـﺎﺌﻥ‬

‫ﺍﻟﺫﻱ ﻴﺤﻤل ﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻔﻌﻠﻴﺔ )ﻭﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ .(Managed Heap‬ﺍﻥ ﻟـﻡ ﺘﻔﻬـﻡ ﺸـﻴﺌﺎ ﻤﻤـﺎ‬
‫ﺴﺒﻕ، ﺭﻜﺯ ﻓﻲ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ ﻭﺍﻟﻤﻭﻀﺤﺔ ) ﺒﺎﻟﺸﻜل 2 -4( ﻓﻲ ﺍﻟﺼﻔﺤﺔ ﺍﻟﺘﺎﻟﻴﺔ:‬

‫ﻣﺘﻐﲑات ﻣ ﺮﺟﻌﻴ ﺔ '‬
‫"ﺗﺮآﻲ اﻟﻌ ﺴﲑ ي" = ‪Dim Name As String‬‬
‫‪Dim Name2 As String = Name‬‬
‫ﻣﺘﻐﲑات ذ ات ﻗﻴ ﻤ ﺔ '‬
‫99 = ‪Dim Age As Integer‬‬
‫‪Dim Age2 As Integer = Age‬‬
‫64‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺸﻜل 2 -4: ﺘﻭﻀﻴﺢ ﺍﻟﻔﺭﻕ ﻓﻲ ﻋﻤﻠﻴﺔ ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ ﺒﻴﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ.‬
‫ﻜﻤﺎ ﺘﺭﻯ ﻓﻲ )ﺍﻟﺸﻜل 2 -4(، ﺭﻏﻡ ﺍﻨﻲ ﻋﺭﻓﺕ ﻤﺘﻐﻴﺭﻴﻥ ﻤﺨﺘﻠﻔـﻴﻥ )‪ Name‬ﻭ 2‪ (Name‬ﺍﻻ ﺍﻨﻬﻤـﺎ‬
‫ﻻ ﻴﺯﺍﻻﻥ ﻴﺸﻴﺭﺍﻥ ﺍﻟﻰ ﻨﻔﺱ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻔﻌﻠﻴﺔ ﻟﻠﻤﺘﻐﻴﺭ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ ،Managed Heap‬ﺒﻴﻨﻤﺎ ﺘﺴـﺘﻘل ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ‬
‫)‪ Age‬ﻭ 2‪ (Age‬ﺒﻘﻴﻤﻬﺎ ﻓﻲ ﻤﻨﺎﻁﻕ ﻤﺨﺘﻠﻔﺔ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ.‬
‫ﻣﻼﺣﻈﺔ‬
‫ﻣﺆﺷﺮات اﻟﻤﺘﻐﻴﺮات اﻟﻤﺮﺟﻌﻴﺔ )اﻟﻤﻮﺟﻮدة ﻓﻲ ﻗﺴﻢ ‪ (Stack‬ﺣﺠﻤﻬﺎ 4 ﺑﺎﻳﺖ‬
‫ﻣﻬﻤﺎ اﺧﺘﻠﻒ ﻧﻮع اﻟﻘﻴﻢ اﻟﺘﻲ ﺗﺸﻴﺮ ﻟﻬﺎ.‬

‫ﺍﻟﻌﺒﺎﺭﺓ ‪:Option Strict‬‬
‫ﻋﻠﻰ ﻤﺭ ﺍﻻﺠﻴﺎل ﺍﻟﺴﺎﺒﻘﺔ ﻤﻥ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ، ﻭﺍﺠﻪ ﺍﻟﻤﺒﺭﻤﺠﻭﻥ ﻤﻌﺎﻨﺎﺓ ﻜﺒﻴﺭﺓ ﻓـﻲ ﻤﺴـﺄﻟﺔ ﺘﺤﻭﻴـل ﺍﻟﺒﻴﺎﻨـﺎﺕ‬
‫ﺍﻟﻤﺨﺘﻠﻔﺔ ﻤﻥ ﺍﻟﻘﻴﻡ. ﻤﻊ ﺫﻟﻙ، ﻟﻥ ﺘﻭﺍﺠﻪ ﺍﻱ ﻤﺸﺎﻜل ﻋﻨﺩ ﺍﺘﺒـﺎﻉ ﺍﺴـﻠﻭﺏ ﺍﻟﺘﺤﻭﻴـل ﺍﻟﻭﺍﺴـﻊ ‪Widening‬‬
‫‪ ،Conversion‬ﺤﻴﺙ ﺍﻥ ﺍﻟﺘﺤﻭﻴل ﺍﻟﻭﺍﺴﻊ ﻴﻘﻭﻡ ﺒﻨﺴﺦ ﻗﻴﻤﺔ ﻤﻥ ﻨﻭﻉ ﺼﻐﻴﺭ )‪ Short‬ﻤﺜﻼ( ﺍﻟﻰ ﻨـﻭﻉ ﺍﻜﺒـﺭ‬
‫ﻤﻨﻪ ) ﻜـ ‪ (Double‬ﻤﻤﺎ ﻻ ﻴﺅﺩﻱ ﺍﻟﻰ ﺍﻟﺘﻀﺤﻴﺔ ﺒﺩﻗﺔ ﺍﻟ ﻘﻴﻤﺔ:‬
‫01 = ‪Dim A As Short‬‬
‫ﻻ ﻣﺸﻜﻠ ﺔ ' ‪Dim B As Double = A‬‬
‫01 ' )‪ArabicConsole.WriteLine(A‬‬
‫01 ' )‪ArabicConsole.WriteLine(B‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫74‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻭﻋﻠﻰ ﺍﻟﻌﻜﺱ ﻤﻥ ﺫﻟﻙ، ﻟﻭ ﻜﺎﻥ ﻟﺩﻴﻨﺎ ﻤﺘﻐﻴﺭ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Double‬ﻭﺍﺭﺩﺕ ﺍﺴـﻨﺎﺩ ﻗﻴﻤﺘـﻪ ﺍﻟـﻰ ﻤﺘﻐﻴـﺭ‬
‫ﺍﺨﺭ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ ،Single‬ﺴﺘﻔﻘﺩ ﻫﺫﻩ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﺩﻗﺔ ﺍﻟﻌﺩﺩﻴﺔ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﻤﺘﻐﻴﺭ ﺍﻟﺴـﺎﺒﻕ، ﺍﻟﺴـﺒﺏ ﻭﺍﻀـﺢ‬

‫ﻻﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Double‬ﺘﺴﺘﻁﻴﻊ ﺤﻤل ﻗﻴﻡ ﺍﻜﺜﺭ ﺩﻗﺔ ﻤﻥ ﺍﻟﻨﻭﻉ ‪:Single‬‬

‫9999999.3 = ‪Dim A As Double‬‬
‫‪Dim B As Single = A‬‬
‫9999999.3 '‬
‫4 '‬

‫)‪ArabicConsole.WriteLine(A‬‬
‫)‪ArabicConsole.WriteLine(B‬‬

‫ﻓﻲ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ، ﻴﻀﻁﺭ ‪ Visual Basic .NET‬ﺍﻟﻰ ﺍﺠﺭﺍﺀ ﻋﻤﻠﻴﺔ ﺍﻟﺘﺤﻭﻴل ﺍﻟﺘﻠﻘﺎﺌﻴﺔ ﺤﺘـﻰ ﻻ ﻴﺘﻌـﺩﻯ‬

‫ﺤﺩﻭﺩ ﻤﺠﺎل ﺍﻟﻘﻴﻡ ﺍﻟﺘﻲ ﺘﺴﻤﺢ ﻟﻠﻤﺘﻐﻴﺭﺍﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Single‬ﺤﻤﻠﻬﺎ، ﻤﻤﺎ ﻴﺅﺩﻱ ﺍﻟﻰ ﺍﻟﺘﻀـﺤﻴﺔ ﺒﺩﻗـﺔ ﺍﻟـﺭﻗﻡ‬
‫ﺍﻟﻤﺤﻔﻭﻅـﺔ ﻓـﻲ ﺍﻟﻨـﻭﻉ ‪ .Double‬ﻴﻌـﺭﻑ ﻫـﺫﺍ ﺍﻟﻨـﻭﻉ ﻤـﻥ ﺍﻟﺘﺤﻭﻴـل ﺒﺎﻟﺘﻀـﻴﻴﻕ ‪Narrowing‬‬
‫‪ ،Conversion‬ﺍﻱ ﺍﻨﻙ ﺘﻀﻴﻕ ﺍﻟﻘﻴﻤﺔ ﻤﻥ ﻤﺘﻐﻴﺭ ﻜﺒﻴﺭ )ﻜـ ‪ (Double‬ﺍﻟﻰ ﻤﺘﻐﻴﺭ ﺍﺼـﻐﺭ ﻤﻨـﻪ )ﻭﻫـﻭ‬

‫‪ .(Single‬ﺍﻤﺜﻠﺔ ﺍﺨﺭﻯ: ﺍﻟﺘﺤﻭﻴل ﻤﻥ ‪ Long‬ﺍﻟﻰ ‪ Integer‬ﺍﻟﻰ ‪ Short‬ﺍﻟﻰ ‪... Byte‬ﺍﻟﺦ.‬
‫ﺍﻟﺘﻀﻴﻴﻕ ﺴﺒﺏ ﺭﺌﻴﺴﻲ ﻻﻤﺭﺍﺽ ﺍﻟﺒﺭﺍﻤﺞ )ﺍﻟﺸﻭﺍﺌﺏ ‪ ،(Bugs‬ﺍﻻ ﺍﻨـﻙ ﺘﺴـﺘﻁﻴﻊ ﺍﺴـﺘﺨﺩﺍﻡ ﺍﻟﻌﺒـﺎﺭﺓ‬

‫‪ Option Strict On‬ﻓﻲ ﺍﻋﻠﻰ ﺍﻟﻤﻠﻑ ﺤﺘﻰ ﺘﻤﻨﻊ ﻨﻔﺴﻙ ﻜﻤﺒﺭﻤﺞ ﻭ ‪ Visual Basic .NET‬ﻜﻤﺘﺭﺠﻡ ﻤﻥ‬
‫ﺍﺠﺭﺍﺀ ﻋﻤﻠﻴﺔ ﺍﻟﺘﻀﻴﻴﻕ ﺍﻟﺘﻠﻘﺎﺌﻴﺔ ﺒﻴﻥ ﺍﻻﻨﻭﺍﻉ ﺍﻟﻤﺨﺘﻠﻔﺔ ﻤﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ، ﻟﺫﻟﻙ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ ﺴﺘﻅﻬﺭ ﻟـﻙ ﺭﺴـﺎﻟﺔ‬

‫ﺨﻁﺄ ﺍﻥ ﻜﺎﻨﺕ ﺍﻟﻌﺒﺎﺭﺓ ‪ Option Strict On‬ﻤﺴﻁﻭﺭﺓ:‬

‫ﻣﻨﻊ ﻋﻤﻠﻴ ﺔ اﻟﺘ ﻀﻴﻴ ﻖ '‬
‫‪Option Strict On‬‬
‫1‪Module Module‬‬
‫)(‪Sub Main‬‬
‫1 = ‪Dim A As Double‬‬
‫‪Dim B As Single‬‬
‫اﻟﺘﺤﻮ ﻳﻞ اﻟ ﻮاﺳﻊ ﳑﻜ ﻦ '‬

‫‪A = B‬‬

‫رﺳﺎﻟﺔ ﺧﻄﺄ ﺑﺴﺒﺐ اﻟﺘﻀﻴ ﻴ ﻖ '‬

‫‪B = A‬‬
‫‪End Sub‬‬
‫‪End Module‬‬

‫ﻣﻼﺣﻈﺔ‬
‫ﺗﺄﺛﻴﺮ اﻟﻌﺒﺎرة ‪ Option Strict‬ﻳﺸﻤﻞ اﻟﻤﻠﻒ اﻟﺬي ﺳﻄﺮت ﻓﻴﻪ ﻓﻘﻂ، وان اردت‬
‫ﺷﻤﻠﻬﺎ ﻓﻲ آﺎﻓﺔ ﻣﻠﻔﺎت اﻟﻤﺸﺮوع اﻻﺧﺮى -دون اﻟﺤﺎﺟﺔ ﻟﻜﺘﺎﺑﺘﻬﺎ - ﻳﻤﻜﻨﻚ‬
‫ﺗﻌﺪﻳﻞ اﻋﺪا دات اﻟﻤﺘﺮﺟﻢ ﻓﻲ ﻧﺎﻓﺬة ‪- Project Property Pages‬آﻤﺎ ﻓﻌﻠﻨﺎ‬
‫ﺳﺎﺑﻘﺎ ﻣﻊ ‪) Option Explicit‬ﺷﻜﻞ 2 -2 (.‬
‫84‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻻ ﻴﻘﺘﺼﺭ ﺘﺄﺜﻴﺭ ﺍﻟﻌﺒﺎﺭﺓ ‪ Option Strict‬ﻋﻠﻰ ﺍﻟﺒﻴﺎﻨـﺎﺕ ﺍﻟﻌﺩﺩﻴـﺔ ﻓﻘـﻁ، ﺒـل ﻴﻤﺘـﺩ ﻟﻴﺼـل ﺍﻟـﻰ‬
‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻻﺨﺭﻯ ﻜـ ‪... Boolean ،Date ،String‬ﺍﻟﺦ:‬
‫ﳑﻜﻦ ﰲ ﺣﺎ ﻟ ﺔ '‬
‫‪ Option Strict Off‬ﻓﻘﻂ '‬
‫‪Dim A As String‬‬
‫‪Dim B As Boolean‬‬
‫"‪A = "True‬‬
‫‪B = A‬‬

‫ﻭﻋﻨﺩ ﺍﻟﺤﺩﻴﺙ ﻋﻥ ﺍﻟﻤﻌﺎﻤﻼﺕ، ﻋﻠﻴﻙ ﺍﻟﺘﻔﺭﻴﻕ ﺒﻴﻥ ﻤﻌﺎﻤل ﺍﻟﻘﺴـﻤﺔ  ﺍﻟﺨـﺎﺹ ﺒﺎﻻﻋـﺩﺍﺩ ﺍﻟﺼـﺤﻴﺤﺔ،‬
‫ﻭﺒﻴﻥ ﻤﻌﺎﻤل ﺍﻟﻘﺴﻤﺔ / ﻭﺍﻟﺫﻱ ﻴﺴﺘﺨﺩﻡ ﻟﻼﻋﺩﺍﺩ ﺍﻟﻌﺸﺭﻴﺔ ﻻﻥ ﻋﻤﻠﻴﺔ ﺍﻟﺘﺤﻭﻴل ﻟﻥ ﺘـﺘﻡ ﺘﻠﻘﺎﺌﻴـﹰ، ﻜﻤـﺎ ﺍﻥ ﻤﻌﺎﻤـل‬
‫ﺎ‬
‫ﺍﻻﺱ ^ ﻴﺤﻭل ﺍﻟﻘﻴﻡ ﺍﻟﻰ ‪:Double‬‬

‫رﺳﺎﻟﺔ ﺧﻄ ﺄ ﰲ ﺣ ﺎﻟ ﺔ '‬
‫‪' Option Strict On‬‬
‫‪Dim X As Integer‬‬
‫2 / 01 = ‪X‬‬
‫3 ^ 2 = ‪X‬‬

‫ﻓﻲ ﺍﻟﻤﻘﺎﺒل، ﺘﻔﻌﻴﻠﻙ ﻟﻠﻌﺒﺎﺭﺓ ‪ Option Strict On‬ﻻ ﻴﻌﻨﻲ ﺍﻨﻙ ﻻ ﺘﺴﺘﻁﻴﻊ ﺍﺴﻨﺎﺩ ﺍﻻﻨـﻭﺍﻉ ﺍﻟﻤﺨﺘﻠﻔـﺔ‬
‫ﻤﻥ ﺍﻟﻘﻴﻡ، ﺒل ﻴﻤﻜﻨﻙ ﺍﻻﺴﺘﻤﺭﺍﺭ ﻋﻠﻰ ﺫﻟﻙ ﺸﺭﻴﻁﺔ ﺍﻥ ﺘﻜﻭﻥ ﻟﺒﻕ ﻭﺘﺴﺘﺨﺩﻡ ﺩﻭﺍل ﺍﻟﺘﺤﻭﻴل:‬
‫ﳑﻜﻦ ﻋﻤﻞ ذﻟﻚ ﺣ ﱴ ﻟﻮ ﻓﻌﻠﺖ اﻟﻌﺒﺎ ر ة '‬
‫‪' Option Strict On‬‬
‫2.3 = ‪Dim X As Double‬‬
‫)‪Dim Y As Integer = CInt(X‬‬

‫ﻴﻌﺭﺽ ﻟﻙ ﺍﻟﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺩﻭﺍل ﺍﻟﺘﺤﻭﻴل ﻻﻨﻭﺍﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻻﺨﺭﻯ:‬
‫ﺍﻟﺩﺍﻟﺔ‬
‫‪CBool‬‬
‫‪CByte‬‬
‫‪CChar‬‬
‫‪CDate‬‬
‫‪CDbl‬‬
‫‪CDec‬‬
‫‪CInt‬‬
‫‪CLng‬‬
‫‪CObj‬‬
‫‪CShort‬‬
‫‪CSng‬‬
‫‪CStr‬‬

‫ﺍﻟﻘﻴﻤﺔ ﺍﻟﺘﻲ ﺘﻌﻭﺩ ﺒ ﻬﺎ‬
‫‪Boolean‬‬
‫‪Byte‬‬
‫‪Char‬‬
‫‪Date‬‬
‫‪Double‬‬
‫‪Decimal‬‬
‫‪Integer‬‬
‫‪Long‬‬
‫‪Object‬‬
‫‪Short‬‬
‫‪Single‬‬
‫‪String‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫94‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺍﺨﻴﺭﺍ، ﻤﺎ ﺫﻜﺭﺘﻪ ﻓﻲ ﺍﻟﺴﻁﻭﺭ ﺍﻟﺴﺎﺒﻘﺔ ﺤﻭل ﺘﺄﺜﻴﺭ ﺍﻟﻌﺒﺎﺭﺓ ‪ Option Strict On‬ﻜﺎﻥ ﻤﻭﺠﻬـﺎ ﺍﻟـﻰ‬
‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ ‪ Value Type‬ﺒﺸﻜل ﻤﺒﺎﺸﺭ، ﻭﺒﺎﻟﻨﺴـﺒﺔ ﻟﻠﻜﺎﺌﻨـﺎﺕ ﺍﻟﺤﻘﻴﻘﻴـﺔ –ﺍﻗﺼـﺩ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ‬
‫ﺍﻟﻤﺭﺠﻌﻴﺔ ‪ - Reference Type‬ﻓﻠﻬﺎ ﺴﻭﺍﻟﻴﻑ ﻭﻋﻠﻭﻡ ﺭﺠﺎﺠﻴل ﺍﺨﺭﻯ ﻨﺫﻜﺭﻫﺎ ﻻﺤﻘﺎ ﻓـﻲ ﺍﻟﻔﺼـل ﺍﻟﺜﺎﻟـﺙ‬

‫ﺍﻟﻔﺌﺎﺕ ﻭﺍﻟﻜﺎﺌﻨﺎﺕ ﺒﻤﺸﻴﺌﺔ ﺍﷲ.‬

‫اﻟﺜﻮاﺑﺖ‬
‫ﺒﺸﻜل ﺍﻓﺘﺭﺍﻀﻲ، ﺍﻟﺜﻭﺍﺒﺕ ﺍﻟﻌﺩﺩﻴﺔ ﺍﻟﺼﺤﻴﺤﺔ ﻴﺘﻌﺎﻤل ﻤﻌﻬـﺎ ﺍﻟﻤﺘـﺭﺠﻡ ﻋﻠـﻰ ﺍﻨﻬـﺎ ﻤـﻥ ﺍﻟﻨـﻭﻉ ‪،Integer‬‬
‫ﻭﺍﻻﻋﺩﺍﺩ ﺍﻟﻌﺸﺭﻴﺔ ﻤﻥ ﺍﻟﻨﻭﻉ ‪:Double‬‬
‫ﻗﻴﻤﺔ ﻣ ﻦ اﻟﻨ ﻮ ع ‪ArabicConole.WriteLine (10) ' Integer‬‬
‫ﻗﻴﻤﺔ ﻣﻦ اﻟ ﻨﻮ ع ‪ArabicConole.WriteLine (5.5) ' Double‬‬

‫ﻤﻊ ﺫﻟﻙ، ﻴﻤﻜﻨﻙ ﺘﺤﺩﻴﺩ ﻨﻭﻉ ﺍﻟﺜﺎﺒﺕ ﻟﺯﻴﺎﺩﺓ ﺴﺭﻋﺔ ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ، ﻓﺘﺴﺘﻁﻴﻊ ﺍﺴـﺘﺨﺩﺍﻡ ﺍﻟـﺫﻴل "‪ "L‬ﻟﻠﻨـﻭﻉ ‪،Long‬‬

‫ﺍﻟﺫﻴل "‪ "S‬ﻟﻠﻨﻭﻉ ‪ ،Short‬ﺍﻟﺫﻴل "‪ "D‬ﻟﻠﻨـﻭﻉ ‪ ،Decimal‬ﻭﺍﻟـﺫﻴل "‪ "F‬ﻟﻠﻨـﻭﻉ ‪) Single‬ﺭﺍﺠـﻊ ﺒﻘﻴـﺔ‬
‫ﺍﻻﺨﺘﺼﺎﺭﺍﺕ ﻓﻲ ﻤﻜﺘﺒﺔ ‪:(MSDN‬‬
‫‪Dim X As Long‬‬
‫‪Dim Y As Long‬‬
‫001 = ‪X‬‬
‫‪Y = 100L‬‬

‫اﻻﺳﻨﺎد ا ﻟﺘﺎﱄ اﺳﺮع وذﻟﻚ ﻟﻌﺪم اﺟﺮاء اﻟﺘﺤ ﻮﻳﻞ ا ﻟﻮاﺳ ﻊ '‬

‫ﻭﺒﺎﻟﻨﺴﺒﺔ ﻟﻠﺜﻭﺍﺒﺕ ﺍﻟﺘﻲ ﺘﺤﻤل ﺍﻟﻨﻭﻉ ‪ ،Date‬ﻓﻀ ﻊ ﻗﻴﻤﺔ ﺍﻟﻭﻗﺕ ﻭ/ﺃﻭ ﺍﻟﺘﺎﺭﻴﺦ ﺒﻴﻥ ﺍﻟﺭﻤﺯﻴﻥ # ﻭ #:‬
‫‪Dim X As Date‬‬
‫‪Dim Y As Date‬‬
‫#3002/92/1# = ‪x‬‬
‫#‪Y = #2/15/2003 9:30:00 PM‬‬

‫ﻓﻜﺭﺓ ﺍﻟﺜﻭﺍﺒﺕ ﺍﻟﻤﺴﻤﺎﺓ ﺸﺒﻴﻪ ﺒﻔﻜﺭﺓ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ، ﺍﻻ ﺍﻥ ﻗﻴﻡ ﺍﻟﺜﻭﺍﺒﺕ ﺍﻟﻤﺴﻤﺎﺓ ﻻ ﻴﻤﻜـﻥ ﺘﻌـﺩﻴﻠﻬﺎ ﻭﻗـﺕ‬
‫ﺍﻟﺘﻨﻔﻴﺫ، ﻭﺫﻟﻙ ﻻﻨﻬﺎ ﺘﺴﺘﺒﺩل ﺒﻘﻴﻤﻬﺎ ﺍﺜﻨﺎﺀ ﻋﻤﻠﻴﺔ ﺍﻟﺘﺭﺠﻤﺔ ﻟﻠﺒﺭﻨﺎﻤﺞ، ﻭﻴﺘﻡ ﺤﻔﻅﻬﺎ ﻓﻲ ﻤﻠـﻑ ﺍﻟﺒﺭﻨـﺎﻤﺞ ﺍﻟﻨﻬـﺎﺌﻲ‬

‫)ﻜـ ‪ EXE‬ﻤﺜﻼ(. ﺍﺴﺘﺨﺩﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Const‬ﻟﺘﻌﺭﻴﻑ ﺜﺎﺒﺕ ﺠﺩﻴﺩ:‬

‫"ﻋﺒﺎس ا ﻟﺴﺮﻳ ﻊ" = ‪Const PROGRAMMER_NAME‬‬
‫ﻋﺒﺎس اﻟﺴﺮ ﻳ ﻊ ' )‪ArabicConsole.WriteLine(PROGRAMMER_NAME‬‬

‫ﺘﺤﺩﻴﺩ ﻨﻭﻉ ﺍﻟﺜﺎﺒﺕ ﺍﻤﺭ ﻤﻔﻀل ﻟﺯﻴﺎﺩﺓ ﺍﻟﺴﺭﻋﺔ، ﺒﻴﻨﻤﺎ ﻴﻜـﻭﻥ ﺍﻟﺯﺍﻤـﻲ ﺍﻥ ﻓﻌﻠـﺕ ﺍﻟﻌﺒـﺎﺭﺓ ‪Option‬‬
‫‪:Strict On‬‬
‫"ﻋﺒﺎس ا ﻟﺴﺮﻳ ﻊ" = ‪Const PROGRAMMER_NAME As String‬‬
‫05‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻋﻭﺩﺓ ﺍﻟﻰ ﺍﻟﺜﻭﺍﺒﺕ ﺍﻟﻌﺩﻴﺔ، ﻴﻤﻜﻨﻙ ﻜﺘﺎﺒـﺔ ﺍﻻﻋـﺩﺍﺩ ﺒﺎﻟﺼـﻴﻐﺔ ﺍﻟﺴـﺕ ﻋﺸـﺭﻴﺔ ‪ Hexadecimal‬ﺍﻭ‬
‫ﺍﻟﺜﻤﺎﻨﻴﺔ ‪ Octal‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﺭﻤﻭﺯ ‪ &H‬ﻭ ‪– &O‬ﻋﻠﻰ ﺍﻟﺘﻭﺍﻟﻲ - ﻗﺒل ﺍﻟﻌﺩﺩ:‬
‫552 '‬

‫ﺻﻴﻐﺔ ﺳﺖ ﻋﺸﺮﻳ ﺔ '‬
‫)‪ArabicConsole.WriteLine(&HFF‬‬

‫8 '‬

‫ﺻﻴﻐﺔ ﲦﺎﻧ ﻴ ﺔ '‬
‫)01‪ArabicConsole.WriteLine(&O‬‬

‫ﺘﺫﻜﺭ ﺍﻥ ﺍﻻﻋﺩﺍﺩ –ﺒﺸﻜل ﺍﻓﺘﺭﺍﻀﻲ - ﺘﻜﻭﻥ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ ،Integer‬ﻟﺫﻟﻙ ﻻ ﺘﻨﺴـﻰ ﺍﺴـﺘﺨﺩﺍﻡ ﺍﻟـﺫﻴل ﺍﻟﻤﻨﺎﺴـﺏ‬
‫ﻟﻠﻘﻴﻤﺔ ﺍﻟﻤﻨﺎﺴﺒﺔ، ﻓﺎﻟﻌﺩﺩ ﺍﻟﺘﺎﻟﻲ ﻴﻔﻀل ﺍﺴﻨﺎﺩ ﺍﻟﺫﻴل "‪ "L‬ﻟﻪ ﺤﺘﻰ ﻨﺨﺭﺝ ﺒﺎﻟﻨﺘﻴﺠﺔ ﺍﻟﻤﻨﺎﺴﺒﺔ:‬
‫1- '‬
‫5927694924 '‬

‫)‪ArabicConsole.WriteLine(&HFFFFFFFF‬‬
‫)‪ArabicConsole.WriteLine(&HFFFFFFFFL‬‬

‫ﺍﺨﻴﺭﺍ، ﻻﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺼـﻴﻐﺔ ﺍﻟﺴـﺕ ﻋﺸـﺭﻴﺔ ‪ Hexadecimal‬ﺍﻭ ﺍﻟﺜﻤﺎﻨﻴـﺔ ‪ Octal‬ﻟﻼﻋـﺩﺍﺩ‬
‫ﺍﻟﻌﺸﺭﻴﺔ:‬
‫ﺑﻮدي وﻟﻜ ﻦ ﻟﻼﺳ ﻒ ﻏﲑ ﳑﻜ ﻦ '‬
‫)52.‪ArabicConsole.WriteLine(&HFF‬‬

‫اﻟﺘﺮآﻴﺒﺎت واﻟﻤﺼﻔﻮﻓﺎت‬
‫ﻋﺒﺭ ﺍﻟﺯﻤﻥ ﻭﻤﻊ ﺍﻻﻴﺎﻡ، ﺴﺘﺒﺩﺃ ﺒﺘﻌﺭﻴﻑ ﺍﻨﻭﺍﻉ ﺨﺎﺼﺔ ﺒﻙ ﻓﻲ ﺒﺭﺍﻤﺠﻙ ﺍﻟﺠﺩﻴـﺔ ﺘﻌـﺭﻑ ﺒﺎﻟﺘﺭﻜﻴﺒـﺎﺕ، ﻭﺍﻟﺘـﻲ‬

‫ﻴﺩﻋﻤﻬﺎ ‪ Visual Basic .NET‬ﺒﻘﻭﺓ. ﻓﻲ ﻫﺫﺍ ﺍﻟﻘﺴﻡ ﻤﻥ ﺍﻟﻔﺼل ﺴـﺄﺘﺤﺩﺙ ﻋـﻥ ﺍﻟﺘﺭﻜﻴﺒـﺎﺕ ﻤـﻥ ﻨـﻭﻉ‬
‫‪ Enum‬ﻭﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻤﻥ ﻨﻭﻉ ‪ ،Structure‬ﻜﻤﺎ ﺴﺄﺨﺼﺹ ﻓﻘﺭﺓ ﻜﺎﻤﻠﺔ ﺤﻭل ﺍﻟﻤﺼﻔﻭﻓﺎﺕ.‬

‫اﻟﺘﺮآﻴﺒﺎت ﻣﻦ ﻧﻮع ‪Enum‬‬
‫ﻴﻤﻜﻨﻙ ﺘﻌﺭﻴﻑ ﻨﻭﻉ ﻤﻌﻴﻥ ﻤﻥ ﺍﻨﻭﺍﻉ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺒﺤﻴﺙ ﺘﺤﺼﺭ ﻤﺠﺎل ﺍﻟﻘﻴﻡ ﺍﻟﺘﻲ ﺘﺴـﻨﺩﻫﺎ ﺍﻟﻴﻬـﺎ ﺘﻌـﺭﻑ ﺒﺎﻟــ‬
‫‪ .Enumeration‬ﺍﺴﺘﺨﺩﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Enum‬ﻟﺘﻌﺭﻴﻑ ﺘﺭﻜﻴﺏ ﺠﺩﻴـﺩ ﺍﻤـﺎ ﻋﻠـﻰ ﻤﺴـﺘﻭﻯ ﺍﻟﻭﺤـﺩﺓ‬

‫ﺍﻟﺒﺭﻤﺠﻴﺔ ‪ ،Module‬ﺍﻭ ﺨﺎﺭﺝ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ، ﺍﻭ ﺩﺍﺨل ﺘﺭﻜﻴﺏ ﺍﺨـﺭ ﻭﻟﻜـﻥ ﻤـﻥ ﺍﻟﻨـﻭﻉ ‪.Structure‬‬
‫ﻫﺫﺍ ﺍﻟﻤﺜﺎل ﻋﺭﻓﺕ ﻓﻴﻪ ﺘﺭﻜﻴﺏ ﻴﻤﺜل ﺍﻴﺎﻡ ﺍﻻﺴﺒﻭﻉ:‬

‫‪Enum Day‬‬
‫‪Saturday‬‬
‫‪Sunday‬‬
‫‪Monday‬‬
‫‪Tuesday‬‬
‫‪Wednesday‬‬
‫‪Thursday‬‬
‫‪Friday‬‬
‫‪End Enum‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫15‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻭﺍﻻﻥ ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺘﺭﻜﻴﺏ ﺍﻟﺴﺎﺒﻕ ﻭﺘﻌﺭﻴﻑ ﻤﺘﻐﻴﺭﺍﺕ ﺠﺩﻴﺩﻩ ﻤﻨﻪ:‬
‫‪Dim x As Day‬‬
‫‪Dim y As Day‬‬
‫‪x = Day.Friday‬‬
‫‪y = x‬‬

‫ﻣﻼﺣﻈﺔ‬
‫ﺗﻘﻨﻴﺎ، ﺗ ﺼﻨﻒ اﻟﺘﺮآﻴﺒﺎت ﻣﻦ اﻟﻨﻮع ‪ Enum‬ﺿـﻤﻦ اﻟﺜﻮاﺑـﺖ، ﻓﻬـﻲ آﺎﻟﺜﻮاﺑـﺖ‬
‫اﻟﻤﺴﻤﺎة -اﻟﺘﻲ ﺗﻄﺮﻗﺖ ﻟﻬﺎ ﺳﺎﺑﻘﺎ - ﺣﻴﺚ ان ﻗﻴﻤﻬﺎ ﺗﺴﺘﺒﺪل اﺛﻨـﺎء ﻋﻤﻠﻴـﺔ‬
‫اﻟﺘﺮﺟﻤﺔ.‬

‫ﻋﻤﻠﻴﺎ، ﺴﺘﺴﺘﺨﺩﻡ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻤﻥ ﻨﻭﻉ ‪ Enum‬ﻜﻭﺴﻴﻁﺎﺕ ﺘﺭﺴﻠﻬﺎ ﺍﻟﻰ ﺍﻻﺠﺭﺍﺀﺍﺕ:‬
‫)‪Sub ShowDay(ByVal CurrentDay As Day‬‬
‫‪If CurrentDay = Day.Friday Then‬‬
‫)"اﺟﺎز ة"(‪ArabicConsole.WriteLine‬‬
‫‪End If‬‬
‫…‬
‫…‬
‫‪End Sub‬‬

‫ﺜﻡ ﺘﺭﺴل ﺍﻟﻴﻬﺎ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻤﻥ ﻨﻔﺱ ﻨﻭﻉ ﺍﻟﺘﺭﻜﻴﺏ ﺍﻭ ﻗﻴﻡ ﺍﻟﺘﺭﻜﻴﺏ ﻤﺒﺎﺸﺭﺓ:‬
‫‪Dim X As Day‬‬
‫‪X = Day.Friday‬‬
‫)‪ShowDay(X‬‬
‫)‪ShowDay(Day.Friday‬‬

‫ﺘﺒﺩﺃ ﻗﻴﻡ ﻋﻨﺎﺼﺭ ﺍﻟﺘﺭﻜﻴﺏ ﻤﻥ ﺍﻟﺭﻗﻡ 0، ﻤﻊ ﺫﻟﻙ ﻴﻤﻜﻨﻙ ﺘﺨﺼﻴﺹ ﻗﻴﻡ ﺍﺨﺭﻯ ﺒﻜل ﺍﻨﺴﻴﺎﺒﻴﺔ:‬
‫‪Enum Day‬‬
‫01 = ‪Saturday‬‬
‫02 = ‪Sunday‬‬
‫‪Monday‬‬
‫‪Tuesday‬‬
‫‪Wednesday‬‬
‫‪Thursday‬‬
‫‪Friday‬‬
‫‪End Enum‬‬

‫ﻤﻊ ﺍﻟﻌﻠﻡ ﺍﻥ ﻤﻘﺩﺍﺭ ﺍﻟﺯﻴﺎﺩﺓ ﻟﺒﺎﻗﻲ ﻋﻨﺎﺼﺭ ﺍﻟﺘﺭﻜﻴﺏ ﻫﻭ ﻭﺍﺤـﺩ. ﺃﻱ ﺃﻥ ‪ Monday‬ﺴـﻴﺤﻤل ﺍﻟﻘﻴﻤـﺔ 12، ﻭ‬
‫‪ Tuesday‬ﺴﻴﺤﻤل ﺍﻟﻘﻴﻤﺔ 22، ... ﻭﻫﻜﺫﺍ.‬
‫25‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺠﻤﻴﻊ ﺍﻟﻘﻴﻡ ﺍﻟﺘﻲ ﻋﺭﻓﺘﻬﺎ ﻓﻲ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﺍﻟﺴﺎﺒﻘﺔ ﻫﻲ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ ،Integer‬ﻤﻊ ﺫﻟـﻙ ﻴﻤﻜﻨـﻙ ‪Visual‬‬
‫‪ Basic .NET‬ﻤﻥ ﺘﻐﻴﻴﺭﻫﺎ ﺍﻟﻰ ‪ ،Short ،Byte‬ﺍﻭ ‪ Long‬ﺭﻏﻡ ﺍﻥ ﻤﺴﺘﻨﺩﺍﺕ ‪ .NET‬ﻻ ﺘﻨﺼﺤﻙ ﺒﻌﻤـل‬

‫ﺫﻟﻙ ﺍﻻ ﻋﻨﺩ ﻭﺠﻭﺩ ﺴﺒﺏ ﻤﻘﻨﻊ ﻟﻌﻤل ﺫﻟﻙ:‬

‫‪Enum Day As Long‬‬
‫‪Saturday‬‬
‫‪Sunday‬‬
‫…‬
‫…‬
‫‪End Enum‬‬

‫ﻭﻟﻠﺤﺩﻴﺙ ﻋﻥ ﻤﺩﻯ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ، ﻓﺎﺨﺘﺼﺭ ﻋﻠﻴﻙ ﺍﻟﻜﻼﻡ ﺒـﺎﻟﻘﻭل: ﺍﻥ ﻋﺭﻓـﺕ ﺍﻟﺘﺭﻜﻴـﺏ‬
‫ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ ،Private‬ﻓﺎﻥ ﻤﺩﻯ ﻫﺫﺍ ﺍﻟﺘﺭﻜﻴﺏ ﺴﻴﻜﻭﻥ ﻤﺤﺼﻭﺭﺍ ﺩﺍﺨـل ﺍﻟﻭﺤـﺩﺓ ﺍﻟﺒﺭﻤﺠﻴـﺔ‬
‫ﹰ‬
‫ﺍﻟﺫﻱ ﻋﺭﻑ ﻓﻴﻬﺎ ﻫﺫﺍ ﺍﻟﺘﺭﻜﻴﺏ، ﺍﻤﺎ ﺍﻥ ﺍﺴﺘﺨﺩﻤﺕ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Public‬ﺍﻭ ﺤﺘـﻰ ﺘﺠﺎﻫﻠﺘﻬـﺎ ﻓﺴـﻴﻜﻭﻥ‬

‫ﺍﻟﻤﺩﻯ ﺸﺎﻤﻼ ﻟﺒﺎﻗﻲ ﻤﻠﻔﺎﺕ ﺍﻟﻤﺸﺭﻭﻉ:‬
‫ﹰ‬
‫1‪Module Module‬‬
‫ﻋﺎم '‬
‫‪Enum GlobalEnum‬‬
‫1‪Enum‬‬
‫2‪Enum‬‬
‫…‬
‫‪End Enum‬‬
‫ﻋﺎم اﻳﻀ ﺎ '‬
‫2‪Public Enum GlobalEnum‬‬
‫1‪Enum‬‬
‫2‪Enum‬‬
‫…‬
‫‪End Enum‬‬
‫ﻋﻠﻰ ﻣﺴ ﺘﻮى ا ﻟﻮﺣﺪة اﻟﱪﳎ ﻴ ﺔ'‬
‫‪Private Enum PrivateEnum‬‬
‫1‪Enum‬‬
‫2‪Enum‬‬
‫…‬
‫‪End Enum‬‬
‫…‬
‫…‬
‫‪End Module‬‬

‫ﻣﻼﺣﻈﺔ‬
‫ﻳﻤﻜﻨﻚ اﻳ ﻀﺎ ﺗﻌﺮﻳﻒ اﻟﺘﻜﺮﻳﺒﺎت ﻣﻦ ﻧﻮع ‪ Enum‬ﺧﺎرج اﻟﻮﺣـﺪات اﻟﺒﺮﻣﺠﻴـﺔ، اﻻ‬
‫اﻧﻚ ﻟﻦ ﺗﺴﺘﻄﻴﻊ اﺳﺘﺨﺪام اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ Priv ate‬ﻓﻲ هﺬﻩ اﻟﺤﺎﻟﺔ. اﻣﺎ‬
‫ان ﻋﺮﻓﺖ اﻟﺘﺮآﻴﺒﺎت ﻣـﻦ ﻧـﻮع ‪ Enum‬داﺧـﻞ ﺗﺮآﻴﺒـﺎت ﻣـﻦ ﻧـﻮع ‪Structure‬‬
‫ﻓﺎﻟﻮ ﺿﻊ ﺳﻴﻜﻮن ﻣﺜﻞ ﻣﺎ آﺎن ﻋﻠﻴﻪ ﻣﻊ اﻟﻮﺣﺪات اﻟﺒﺮﻣﺠﻴﺔ.‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫35‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺍﻟﻤﺯﻴﺩ ﺍﻴﻀﺎ، ﺘﺴﺘﻁﻴﻊ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Friend‬ﻭﺍﻟﺘﻲ ﺘﻤﺎﺜل ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠـﻭﺯﺓ ‪،Public‬‬
‫ﺍﻻ ﺍﻥ ﺍﻻﻭﻟﻰ ﻻ ﺘﺴﻤﺢ ﻟﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺘﺭﻜﻴﺏ ﻤﻥ ﺨﺎﺭﺝ ﺤﺩﻭﺩ ﺍﻟﻤﺸﺭﻭﻉ.‬

‫اﻟﺘﺮآﻴﺒﺎت ﻣﻦ ﻧﻮع ‪Structure‬‬
‫ﻴﻌﺭﻑ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﺒﺎﻻﻨﻭﺍﻉ ﺍﻟﻤﻌﺭﻓـﺔ ﻤـﻥ ﻗﺒـل ﺍﻟﻤﺴـﺘﺨﺩﻡ ‪– User Defined Types‬‬
‫)‪ ،(UDT‬ﺒﺤﻴﺙ ﺘﻤﻜﻨﻙ ﻤﻥ ﺩﻤﺞ ﺍﻨﻭﺍﻉ ﻤﺨﺘﻠﻔﺔ ﻤﻥ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﻭﻀـﻤﻬﺎ ﻓـﻲ ﺘﺭﻜﻴـﺏ ﺍﻭ ﻜﺘﻠـﺔ ﻭﺍﺤـﺩﺓ.‬
‫ﺍﺴﺘﺨﺩﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Structure‬ﻟﺘﻌﺭﻴﻑ ﺘﺭﻜﻴﺏ ﺠﺩﻴﺩ:‬
‫‪Structure Person‬‬
‫‪Dim Name As String‬‬
‫‪Dim Age As Integer‬‬
‫‪End Structure‬‬

‫ﺜﻡ ﺘﻌﺭﻑ ﻤﺘﻐﻴﺭﺍﺕ ﺠﺩﻴﺩﺓ ﻤﻥ ﻫﺫﺍ ﺍﻟﺘﺭﻜﻴﺏ ﻭﺘﺘﻌﺎﻤل ﻤﻌﻬﺎ ﻜﺎﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﺩﻴﺔ:‬
‫‪Dim Turki As Person‬‬
‫"ﺗﺮآﻲ اﻟﻌﺴﲑ ي" = ‪Turki.Name‬‬
‫99 = ‪Turki.Age‬‬
‫ﺗﺮآﻲ اﻟﻌﺴ ﲑ ي ' )‪ArabicConsole.WriteLine(Turki.Name‬‬
‫99 ' )‪ArabicConsole.WriteLine(Turki.Age‬‬

‫ﺍﻟﻤﺯﻴﺩ ﺍﻴﻀﺎ، ﻴﻤﻜﻨﻙ ﻨﺴﺦ ﻗﻴﻡ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﺒﺎﻨﺴﻴﺎﺒﻴﺔ ﻜﺎﻤﻠﺔ ﻜﻤﺎ ﺘﻔﻌل ﻤﻊ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺍﻟﻌﺎﺩﻴـﺔ، ﺸـﺭﻴﻁﺔ‬

‫ﺍﻥ ﺘﻜﻭﻥ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻤﺘﻁﺎﺒﻘﺔ:‬

‫‪Dim Turki2 As Person‬‬
‫‪Turki2 = Turki‬‬
‫ﺗﺮآﻲ اﻟﻌﺴﲑ ي ' )‪ArabicConsole.WriteLine(Turki2.Name‬‬
‫99 ' )‪ArabicConsole.WriteLine(Turki2.Age‬‬

‫ﺒﻌﻀﺎ:‬

‫ﻻ ﺘﻨﺴﻰ ﺍﻥ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻤﻥ ﻨﻭﻉ ‪ Structure‬ﻴﻤﻜﻥ ﺍﻥ ﺘﻜﻭﻥ ﻤﺘﺩﺍﺨﻠﺔ ‪ ،Nested‬ﺍﻱ ﻴﺤﺘـﻭﻱ ﺒﻌﻀـﻬﺎ‬

‫‪Structure Person‬‬
‫‪Structure AddressStruct‬‬
‫‪Dim City As String‬‬
‫‪Dim Countrey As String‬‬
‫‪End Structure‬‬
‫‪Dim Name As String‬‬
‫‪Dim Age As Integer‬‬
‫‪Dim Address As AddressStruct‬‬
‫‪End Structure‬‬
‫45‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﻋﻨﺎﺼﺭ ﺍﻟﺘﺭﻜﻴﺏ ﺍﻟﻤﺤﻀﻭﻥ ﻴﺘﻡ ﻤﻥ ﺨﻼل ﺍﻟﺘﺭﻜﻴﺏ ﺍﻟﺤﺎﻀﻥ ﻟﻬﺎ ﺒﻜل ﻤﻨﻁﻘﻴﺔ:‬
‫‪Dim Turki As Person‬‬
‫"ﺗﺮآﻲ اﻟﻌﺴﲑ ي" = ‪Turki.Name‬‬
‫99 = ‪Turki.Age‬‬
‫"اﻟﻈﻬﺮا ن" = ‪Turki.Address.City‬‬
‫"اﳌﻤﻠﻜﺔ اﻟﻌﺮﺑ ﻴﺔ اﻟ ﺴﻌﻮدﻳ ﺔ" = ‪Turki.Address.Countrey‬‬

‫ﺒﺎﻻﻀﺎﻓﺔ ﺍﻟﻰ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ، ﻋﻠﻴﻙ ﻤﻌﺭﻓﺔ ﺍﻥ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻤﻥ ﻨـﻭﻉ ‪ Structure‬ﻓـﻲ ‪Visual Basic‬‬

‫‪ .NET‬ﻫﻲ ﺘﺭﻜﻴﺒﺎﺕ ﻤﻁﻭﺭﺓ ﻭﻤﺭﻨﺔ ﺠﺩﺍ )ﻤﺜل ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﻟﻐﺔ ++‪ ،(C‬ﻓﻬـﻲ ﺘﻤﻜﻨـﻙ ﻤـﻥ‬
‫ﺘﻌﺭﻴﻑ ﻋﻨﺎﺼﺭ ﺍﻀﺎﻓﻴﺔ ﻓﻲ ﺩﺍﺨل ﺍﻟﺘﺭﻜﻴﺏ ﻜﺎﻟﻁﺭﻕ ‪ Methods‬ﻭﺍﻟﺨﺼﺎﺌﺹ ‪:Properties‬‬
‫‪Structure Person‬‬
‫‪Dim Name As String‬‬
‫‪Dim Age As Integer‬‬
‫ﺗﻌﺮﻳﻒ ﻃ ﺮﻳﻘ ﺔ '‬
‫)(‪Sub ShowData‬‬
‫)‪ArabicConsole.WriteLine(Name‬‬
‫)‪ArabicConsole.WriteLine(Age‬‬
‫‪End Sub‬‬
‫‪End Structure‬‬

‫ﻤﺭﺓ ﺍﺨﺭﻯ، ﻴﻤﻜﻨﻙ ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﻋﻨﺎﺼﺭ ﺍﻟﺘﺭﻜﻴﺏ ﻭﺍﺴﺘﺩﻋﺎﺀ ﻁﺭﻗﻪ ﺒﻨﻔﺱ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻻﻨﺴﻴﺎﺒﻴﺔ:‬
‫‪Dim Turki As Person‬‬
‫"ﺗﺮآﻲ اﻟﻌﺴﲑ ي" = ‪Turki.Name‬‬
‫99 = ‪Turki.Age‬‬
‫)(‪Turki.ShowData‬‬

‫اﻧﻈﺮ اﻳﻀﺎ‬
‫ﺳﺄﺗﻨﺎول اﻟﻄﺮق واﻟﺨ ﺼـﺎﺋﺺ ﺑﺸـﻜﻞ ﻣﻔ ﺼـﻞ ﻓـﻲ اﻟﻔ ﺼـﻞ اﻟﺜﺎﻟـﺚ اﻟﻔﺌـﺎت‬
‫واﻟﻜﺎﺋﻨﺎت.‬

‫ﻻ ﺍﺭﻴﺩ ﺍﻥ ﺍﺸﺘﺕ ﺘﻔﻜﻴﺭﻙ ﺍﻻﻥ ﺒﻤﻭﻀﻭﻉ ﺍﻟﻁﺭﻕ ﻭﺍﻟﺨﺼﺎﺌﺹ ) ﻓﻬﻲ ﺤـﺩﻴﺙ ﺍﻟﻔﺼـل ﺍﻟﺜﺎﻟـﺙ ﻜﻤـﺎ‬

‫ﺫﻜﺭﺕ ﻓﻲ ﺍﻟﻤﺭﺒﻊ ﺍﻻﻋﻠﻰ(، ﻭﻟﻜﻥ ﺩﻋﻨﻲ ﺍﻟﻤﺢ ﻟﻙ ﻫﻨـﺎ ﺍﻥ ﺍﻟﻤﺸـﻴﺩﺍﺕ ‪ Constructers‬ﻤﺩﻋﻭﻤـﺔ ﺒﺸـﻜل‬
‫ﻤﺨﻔﻲ ﻓﻲ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ .Structure‬ﻴﺎ ﺍﻟﻬﻰ! ﻤﺎﺫﺍ ﺘﻘﺼﺩ ﻴﺎ ﺘﺭﻜـﻲ ﺒﻜﻠﻤـﺔ ﻤﺨﻔـﻲ؟! ﺍﻗﺼـﺩ ﻴـﺎ‬

‫ﻋﺯﻴﺯﻱ ﺍﻥ ﺍﻻﺠﺭﺍﺀ ‪ Sub New‬ﻤﻌﺭﻑ ﺒﺸﻜل ﺘﻠﻘﺎﺌﻲ ﻓﻲ ﺍﻟﺘﺭﻜﻴﺏ ﺩﻭﻥ ﺍﻥ ﺘﺭﺍﻫـﺎ. ﻭﻟﻤـﺎﺫﺍ ﺘـﻡ ﺍﺨﻔﺎﺌـﻪ؟‬
‫ﺍﻟﺴﺒﺏ ﻴﺎ ﺴﻴﺩﻱ ﺘﻘﻨﻲ ﺒﺤﺕ ﻭﻻ ﺍﻭﺩ ﺍﻥ ﺍﺒﻴﻨﻪ ﺍﻻ ﻓﻲ ﺍﻟﻔﺼﻭل ﺍﻟﻼﺤﻘـﺔ. ﺤﺴـﻨﺎ ﻭﻤـﺎ ﺍﻟﻔﺎﺌـﺩﺓ ﻤﻨـﻪ؟ ﺍﻟﻔﺎﺌـﺩﺓ‬
‫ﺒﺒﺴﺎﻁﺔ ﺍﺴﻨﺎﺩ ﻗﻴﻡ ﺍﺒﺘﺩﺍﺌﻴﺔ ﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﺘﺭﻜﻴﺏ، ﻓﻠﻭ ﺤﺎﻭﻟﺕ ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ ﻭﻗﺕ ﺍﻟﺘﺼﺭﻴﺢ ﻜﻤﺎ ﻓﻌﻠﻨـﺎ ﺴـﺎﺒﻘﺎ ﻋﻨـﺩ‬
‫ﺍﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ:‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫55‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬
‫‪Structure MyStruct‬‬
‫0 = ‪Dim x As Integer‬‬
‫01 = ‪Dim y As Integer‬‬
‫…‬
‫…‬
‫‪End Structure‬‬

‫ﺴﻴﻅﻬﺭ ﻟﻙ ﺍﻟﻤﺘﺭﺠﻡ ﺭﺴﺎﻟﺔ ﺨﻁﺄ ﺘﻔﻴﺩ ﺒﺎﻨﻙ ﻻ ﺘﺴﺘﻁﻴﻊ ﻓﻌل ﺫﻟﻙ )ﺭﻏﻡ ﺍﻨﻲ ﻟﻡ ﺍﺠﺩ ﺴـﺒﺏ ﻤﻨﻁﻘـﻲ ﻤﻘﻨـﻊ ﻻ‬
‫ﻴﺴﻤﺢ ﻟﻲ ﺒﻔﻌل ﺫﻟﻙ(، ﻭﻫﻨﺎ ﻴﺄﺘﻲ ﺩﻭﺭ ﺍﻟﻤﺸـﻴﺩ ﺍﻟﻤﺨﻔـﻲ ‪ Sub New‬ﺍﻟـﺫﻱ ﻴﻘـﻭﻡ ﺒﺎﺴـﻨﺎﺩ ﻗـﻴﻡ ﺍﺒﺘﺩﺍﺌﻴـﺔ‬
‫ﻟﻠﻤﺘﻐﻴﺭﺍﺕ )0 ﻟﻠﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺩﺩﻴﺔ، ﻻ ﺸﺊ ﻟﻠﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﺤﺭﻓﻴﺔ، ﻭﺍﻟﻘﻴﻤﺔ ‪ Nothing‬ﻟﻠﻜﺎﺌﻨـﺎﺕ(. ﻤـﻊ ﺫﻟـﻙ،‬

‫ﻴﻤﻜﻨﻙ ﺘﻌﺭﻴـﻑ ﻤﺸـﻴﺩ ‪ Sub New‬ﺒﻨﻔﺴـﻙ ﻋـﻥ ﻁﺭﻴـﻕ ﺘﻁﺒﻴـﻕ ﻤﺒـﺩﺃ ﻴﻌـﺭﻑ ﺒﺎﻋـﺎﺩﺓ ﺍﻟﺘﻌﺭﻴـﻑ‬
‫‪) Overloading‬ﻭﻫﻭ ﺤﺩﻴﺙ ﺍﻟﻔﺼل ﺍﻟﺜﺎﻟﺙ ﺍﻴﻀﺎ(. ﻟﻌﻤل ﺫﻟﻙ، ﺍﻀﻑ ﻭﺴـﻴﻁﺎﺕ ‪ Parameters‬ﺍﻀـﺎﻓﻴﺔ‬
‫ﻤﻊ ﺍﻻﺠﺭﺍﺀ ‪:Sub New‬‬

‫‪Structure Person‬‬
‫‪Dim Name As String‬‬
‫‪Dim Age As Integer‬‬
‫اﺟﺮاء ﲤﺖ اﻋ ﺎدة ﺗ ﻌﺮﻳﻔ ﻪ ‪' Overload‬‬
‫)‪Sub New(ByVal PersonName As String‬‬
‫‪Name = PersonName‬‬
‫)"ﰎ ﺗﻨ ﻔﻴﺬ ا ﳌﺸﻴ ﺪ"(‪ArabicConsole.WriteLine‬‬
‫‪End Sub‬‬
‫‪End Structure‬‬

‫ﺭﻏﻡ ﺍﻥ ﺍﻟﻭﻅﻴﻔﺔ ﺍﻷﺴﺎﺴﻴﺔ ﻟﻼﺠﺭﺍﺀ ‪ Sub New‬ﻫﻲ ﺍﻟﻌﻤل ﻜﻤﺸـﻴﺩ، ﺍﻻ ﺍﻨـﻪ ﻟـﻥ ﻴـﺘﻡ ﺍﺴـﺘﺩﻋﺎﺌﻪ‬

‫ﺒﻤﺠﺭﺩ ﺍﻨﺸﺎﺀ ﻜﺎﺌﻥ ﻤﻥ ﺍﻟﺘﺭﻜﻴﺏ ﻓﻴﻤﺎ ﻟﻭ ﺼﺭﺤﺕ ﻋﻥ ﻤﺘﻐﻴﺭ ﺠﺩﻴﺩ ﺒﺎﻟﻁﺭﻕ ﺍﻟﺘﻘﻠﻴﺩﻴـﺔ، ﻭﺍﻟـﺩﻟﻴل ﺠـﺭﺏ ﻫـﺫﺍ‬
‫ﺍﻟﺴﻁﺭ:‬

‫ﻣﻊ اﻻﺳﻒ اﻟﺸﺪﻳ ﺪ، ﻟﻦ ﻳﺘﻢ ﺗﻨﻔﻴﺬ اﳌﺸﻴ ﺪ '‬
‫‪Dim Turki As Person‬‬

‫ﺴﺘﻼﺤﻅ ﺍﻥ ‪ Visual Basic .NET‬ﻟﻡ ﻴﻘﻡ ﺒﺘﻨﻔﻴﺫ ﺫﻟﻙ ﺍﻟﻤﺸﻴﺩ، ﻭﺍﻟﺴﺒﺏ ﻗﺩ ﻴﺒـﺩﻭ ﺒـﺩﻴﻬﻴﺎ ﺍﻥ ﺘـﺫﻜﺭﺕ ﺍﻨـﻪ‬
‫ﻴﻭﺠﺩ ﻤﺸﻴﺩ ‪ Sub New‬ﺍﺨﺭ )ﻟﻜﻨﻪ ﻤﺨﻔﻲ( ﺘﻡ ﺘﻨﻔﻴﺫﻩ ﺒﺩﻻ ﻤﻥ ﻤﺸﻴﺩﻨﺎ ﺍﻟﻅﺭﻴﻑ. ﻭﺤﺘﻰ ﻨﺒﻠـﻎ ﻤﺘـﺭﺠﻡ ﺍﻟﻠﻐـﺔ‬
‫ﺍﻥ ﻋﻠﻴﻪ ﺘﻨﻔﻴﺫ ﻤﺸﻴﺩﻨﺎ ﺍﻟﺠﺩﻴﺩ، ﺒﺩﻻ ﻤﻥ ﺍﻟﻤﺸﻴﺩ ﺍﻟﻤﺨﻔﻲ ﻋﻠﻴﻨـﺎ ﺍﺴـﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤـﺔ ﺍﻟﻤﺤﺠـﻭﺯﺓ ‪ New‬ﻭﺍﺭﺴـﺎل‬
‫ﹰ‬
‫ﺍﻟﻭﺴﻴﻁﺎﺕ ﺍﻟﺘﻲ ﺘﻭﺍﻓﻕ ﺫﻟﻙ ﺍﻟﻤﺸﻴﺩ:‬
‫ﺳﻴﺘﻢ ﺗﻨﻔ ﻴﺬ اﳌ ﺸﻴﺪ ﲟ ﺠﺮد ا ﻟﺘﺼﺮﻳ ﺢ ﻋﻦ اﳌﺘﻐﲑ هﻨ ﺎ '‬
‫)"ﺗﺮآﻲ ا ﻟﻌﺴﲑ ي"(‪Dim Turki As New Person‬‬

‫ﻟﻤﺎﺫﺍ؟ ﻜﻴﻑ؟ ﻭﻤﺎﻟﺴﺒﺏ؟ ﻜل ﻫﺫﻩ ﺍﻻﺴﺘﻔﺴﺎﺭﺍﺕ ﺴﺄﺘﻁﺭﻕ ﻟﻬﺎ ﻓﻲ ﺍﻟﻔﺼل ﺍﻟﺜﺎﻟﺙ ﺍﻟﻔﺌـﺎﺕ ﻭﺍﻟﻜﺎﺌﻨـﺎﺕ ﺒﻤﺸـﻴﺌﺔ‬
‫ﺍﷲ، ﻟﺫﻟﻙ ﺍﻁﻠﺏ ﻤﻨﻙ ﻋﺯﻴﺯﻱ ﺍﻟﻘﺎﺭﺉ ﺍﻥ ﻻ ﺘﻘﻠﻕ ﻨﻔﺴﻙ ﻜﺜﻴﺭﺍ ﺒﺎﻻﺸﻴﺎﺀ ﺍﻟﻐﻴـﺭ ﻤﻔﻬﻭﻤـﻪ ﻫﻨـﺎ، ﺤﻴـﺙ ﺍﻨﻬـﺎ‬
‫ﺘﺘﻌﻠﻕ ﺒﺎﻟﻜﺎﺌﻨﺎﺕ ﻭﻁﺭﻴﻘﺔ ﺍﻨﺸﺎﺌﻬﺎ، ﻭﻻ ﺍﻭﺩ ﻨﻘل ﻤﻭﺍﻀـﻴﻊ ﺍﻟﻔﺼـل ﺍﻟﺜﺎﻟـﺙ ﻫﻨـﺎ، ﻓـﻨﺤﻥ ﻤـﺎ ﺯﻟﻨـﺎ ﻨـﺘﻌﻠﻡ‬
‫ﺍﻻﺴﺎﺴﻴﺎﺕ.‬
‫65‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻟﻨﻨﺘﻘل ﺍﻟﻰ ﻤﻭﻀﻭﻉ ﺍﺨﺭ ﻴﺘﻤﺤﻭﺭ ﺤﻭل ﻗﺎﺒﻠﻴﺔ ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﻋﻨﺎﺼﺭ ﺍﻟﺘﺭﻜﻴـﺏ، ﻓﺠﻤﻴـﻊ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ‬
‫ﺍﻟﻤﺤﻀﻭﻨﺔ ﻓﻲ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﺍﻟﺴﺎﺒﻘﺔ ﻋﺭﻓﻨﺎﻫﺎ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ ،Dim‬ﻟـﺫﻟﻙ ﺘﻤﻜﻨـﺎ ﻤـﻥ ﺍﻟﻭﺼـﻭل‬

‫ﺍﻟﻰ ﻋﻨﺎﺼﺭﻫﺎ. ﻭﻟﻜﻨﻙ ﻓﻲ ﺒﻌﺽ ﺍﻻﺤﻴﺎﻥ ﻗﺩ ﺘﻭﺩ ﺘﻌﺭﻴﻑ ﻤﺘﻐﻴﺭﺍﺕ ﻤﺨﻔﻴﺔ ﻻ ﻴﻤﻜﻥ ﺍﻟﻭﺼـﻭل ﺍﻟﻴﻬـﺎ ﺍﻻ ﻤـﻥ‬
‫ﺩﺍﺨل ﺍﻟﺘﺭﻜﻴﺏ ﻨﻔﺴﻪ، ﻟﺫﻟﻙ ﻋﻠﻴﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Private‬ﺍﺜﻨـﺎﺀ ﺍﻟﺘﺼـﺭﻴﺢ ﻋـﻥ ﻤﺘﻐﻴـﺭ ﻓـﻲ‬
‫ﺩﺍﺨل ﺍﻟﺘﺭﻜﻴﺏ:‬
‫‪ Public‬ﻣﺜ ﻞ ‪ Dim‬هﻨﺎ '‬

‫‪Structure Person‬‬
‫‪Public Name As String‬‬
‫‪Dim Age As Integer‬‬
‫‪Private MotherName As String‬‬

‫ﳝﻜﻦ اﻟﻮﺻ ﻮل اﱃ اﳌﺘﻐ ﲑ اﳌﺨ ﻔ ﻲ '‬
‫ﻣﻦ داﺧﻞ اﻟﱰآﻴ ﺐ ﻓﻘ ﻂ '‬

‫)(‪Sub Test‬‬
‫"اﺣﻢ اﺣﻢ !" = ‪MotherName‬‬
‫…‬
‫…‬
‫‪End Sub‬‬
‫‪End Structure‬‬

‫ﺍﻟﻜﻠﻤﺎﺕ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Public‬ﻭ ‪ Private‬ﻓﻲ ﺍﻟﺸـﻴﻔﺭﺓ ﺍﻟﺴـﺎﺒﻘﺔ، ﺘﺴـﻤﻰ ﻤﺤـﺩﺩﺍﺕ ﺍﻟﻭﺼـﻭل ‪Access‬‬
‫‪ .Specifiers‬ﻴﻭﺠﺩ ﻨﻭﻉ ﺜﺎﻟﺙ ﻤﻥ ﻤﺤﺩﺩﺍﺕ ﺍﻟﻭﺼﻭل ﻴﺴﺘﺨﺩﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠـﻭﺯﺓ ‪ Friend‬ﻭﻅﻴﻔﺘـﻪ ﺘﻤﺎﺜـل‬

‫ﻭﻅﻴﻔﺔ ﻤﺤﺩﺩ ﺍﻟﻭﺼﻭل ‪ ،Public‬ﺍﻻ ﺍﻥ ﻋﻨﺎﺼﺭ ﺍﻟﺘﺭﻜﻴﺏ ﻤﻥ ﻫﺫﺍ ﺍﻟﻨـﻭﻉ ﻻ ﻴﻤﻜـﻥ ﺍﻟﻭﺼـﻭل ﺍﻟﻴﻬـﺎ ﻤـﻥ‬
‫ﺨﺎﺭﺝ ﺤﺩﻭﺩ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ )ﺍﻟﺫﻱ ﻋﺭﻑ ﻓﻴﻪ ﺍﻟﺘﺭﻜﻴﺏ(.‬
‫ﻁﻭﻟﻨﺎﻫﺎ ﻭﻫﻲ ﻗﺼﻴﺭﺓ! ﺍﺨﺘﻡ ﻓﻘﺭﺓ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻤﻥ ﻨﻭﻉ ‪ Structure‬ﺒﺘﻭﻀﻴﺢ ﻤـﺩﻯ ﻭ ﻗﺎﺒﻠﻴـﺔ ﺍﻟﺭﺅﻴـﺔ‬

‫ﻟﻬﺎ ﻭﺍﻟﺘﻲ ﺘﻤﺎﺜل ﺍﻟﻤﺩﻯ ﻭ ﻗﺎﺒﻠﻴﺔ ﺍﻟﺭﺅﻴﺔ ﻟﻠﺘﺭﻜﻴﺒﺎﺕ ﻤـﻥ ﻨـﻭﻉ ‪ .Enum‬ﻭﺤﺘـﻰ ﺍﻏﻨﻴـﻙ ﻤـﻥ ﻋﻨـﺎﺀ ﻗﻠـﺏ‬
‫ﺍﻟﺼﻔﺤﺎﺕ ﻟﻠﺒﺤﺙ ﻋﻨﻬﺎ، ﺩﻋﻨﻲ ﺍﻋﻴﺩ ﺼﻴﺎﻏﺘﻬﺎ ﻟﻙ ﻫﻨﺎ: ﺍﻥ ﻋﺭﻓﺕ ﺍﻟﺘﺭﻜﻴـﺏ ﺒﺎﺴـﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤـﺔ ﺍﻟﻤﺤﺠـﻭﺯﺓ‬

‫‪ ،Private‬ﻓﺎﻥ ﻗﺎﺒﻠﻴﺔ ﺍﻟﺭﺅﻴﺔ ﻟﻬﺫﺍ ﺍﻟﺘﺭﻜﻴﺏ ﺴﺘﻜﻭﻥ ﻤﺤﺼﻭﺭﺓ ﺩﺍﺨل ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ ﺍﻟﺫﻱ ﻋﺭﻑ ﻓﻴﻬـﺎ ﻫـﺫﺍ‬
‫ﺍﻟﺘﺭﻜﻴﺏ، ﺍﻤﺎ ﺍﻥ ﺍﺴﺘﺨﺩﻤﺕ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪) Public‬ﺍﻭ ﺤﺘﻰ ﺘﺠﺎﻫﻠﺘﻬﺎ( ﻓﺴﺘﻜﻭﻥ ﻗﺎﺒﻠﻴـﺔ ﺍﻟﺭﺅﻴـﺔ ﺸـﺎﻤﻠﺔ‬
‫ﻟﺒﺎﻗﻲ ﻤﻠﻔﺎﺕ ﺍﻟﻤﺸﺭﻭﻉ. ﻤﻊ ﺍﻟﻌﻠﻡ ﺍﻨﻙ ﺘﺴﺘﻁﻴﻊ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Friend‬ﺍﻴﻀﺎ.‬

‫اﻟﻤﺼﻔﻮﻓﺎت‬

‫ﻴﻤﻜﻨﻙ ‪ Visual Basic .NET‬ﻤﻥ ﺘﻌﺭﻴﻑ ﺍﻟﻤﺼﻔﻭﻓﺎﺕ ﺴﻭﺍﺀ ﻜﺎﻨﺕ ﺍﺤﺎﺩﻴﺔ ﺍﻟﺒﻌﺩ ﺍﻭ ﻤﺘﻌﺩﺩﺓ ﺍﻻﺒﻌﺎﺩ ﻭﺍﻟﺘـﻲ‬
‫ﻗﺩ ﺘﺼل ﺍﻟﻰ 23 ﺒﻌﺩﺍ:‬
‫01 ﻋﻨﺎﺻ ﺮ '‬
‫2 * 2 = 4 ﻋﻨﺎ ﺻ ﺮ '‬

‫‪Dim OneDim (9) As Integer‬‬
‫‪Dim TwoDims (1, 1) As String‬‬

‫ﻴﻤﻜﻨﻙ ﻓﻭﺭﺍ ﺍﻟﺒﺩﺀ ﺒﻌﻤﻠﻴﺔ ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ ﻟﻬﺎ –ﻜﻤﺎ ﺘﻔﻌل ﻤﻊ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﺩﻴـﺔ - ﻤـﻊ ﺍﻟﻌﻠـﻡ ﺍﻥ ﺒـﺩﺀ ﺍﻟﺘـﺭﻗﻴﻡ‬
‫ﻟﻔﻬﺭﺱ ﺍﻟﻤﺼﻔﻭﻓﺎﺕ ﻴﺒﺩﺃ ﺒﺎﻟﺭﻗﻡ 0:‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫75‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬
‫001 = )0( ‪OneDim‬‬
‫002 = )1( ‪OneDim‬‬
‫…‬
‫009 = )9( ‪OneDim‬‬
‫"ﺗﺮآ ﻲ"‬
‫"اﻟﻌﺴ ﲑ ي"‬
‫"ﻋﺒﺎ س"‬
‫"اﻟﺴﺮ ﻳ ﻊ"‬

‫=‬
‫=‬
‫=‬
‫=‬

‫)0‬
‫)1‬
‫)0‬
‫)1‬

‫,0(‬
‫,0(‬
‫,1(‬
‫,1(‬

‫‪TwoDims‬‬
‫‪TwoDims‬‬
‫‪TwoDims‬‬
‫‪TwoDims‬‬

‫ﻭﺍﻥ ﻜﻨﺕ ﻤﺴﺘﻌﺠﻼ ﻓﻲ ﻋﻤﻠﻴﺔ ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ، ﻓﺈﻥ ﻫﺫﺍ ﻤﺘﺎﺡ ﻟﻙ ﻓﻲ ﺴﻁﺭ ﺍﻟﺘﺼﺭﻴﺢ ﻤﺒﺎﺸـﺭ ﹰ، ﺸـﺭﻴﻁﺔ‬
‫ﺓ‬
‫ﹰ‬
‫ﻋﺩﻡ ﺘﺤﺩﻴﺩ ﻋﺩﺩ ﻋﻨﺎﺼﺭ ﺍﻟﻤﺼﻔﻭﻓﺔ:‬
‫}9 ,8 ,7 ,6 ,5 ,4 ,3 ,2 ,1{ = ‪Dim OneDim() As Integer‬‬
‫}}"اﻟﺴﺮﻳ ﻊ" ,"ﻋﺒﺎ س"{ ,}"اﻟﻌﺴﲑ ي" ,"ﺗﺮآ ﻲ"{{ = ‪Dim TwoDims(,) As String‬‬

‫ﺍﻟﻤﺼﻔﻭﻓﺎﺕ ﺍﻟﺴﺎﺒﻘﺔ ﺘﺴﻤﻰ ﻤﺼـﻔﻭﻓﺎﺕ ﺩﻴﻨﺎﻤﻴﻜﻴـﺔ ‪ Dynamics Arrays‬ﻻﻨﻨـﺎ ﻟـﻡ ﻨﺤـﺩﺩ ﻋـﺩﺩ‬
‫ﻋﻨﺎﺼﺭﻫﺎ، ﺍﻟﻤﻴﺯﺓ ﻓﻲ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺼﻔﻭﻓﺎﺕ ﻫﻭ ﺍﻤﻜﺎﻨﻴﺔ ﺘﻐﻴﻴﺭ ﺤﺠﻤﻬـﺎ ﻤـﻥ ﻭﻗـﺕ ﻻﺨـﺭ ﺒﺎﺴـﺘﺨﺩﺍﻡ‬
‫‪ ،ReDim‬ﻤﻊ ﺍﻻﺸﺎﺭﺓ ﺇﻟﻰ ﺍﻥ ﻋﻨﺎﺼﺭ ﺍﻟﻤﺼﻔﻭﻓﺔ ﺍﻟﻤﻌﺎﺩ ﺘﻐﻴﻴﺭ ﺤﺠﻤﻬﺎ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪ ReDim‬ﺴﻭﻑ ﺘﻠﻐﻰ:‬

‫)99( ‪ReDim OneDim‬‬
‫)01 ,01( ‪ReDim TwoDims‬‬
‫0 ' ) )0(‪ArabicConsole.WriteLine ( OneDim‬‬

‫ﻤﻊ ﺫﻟﻙ، ﻴﻤﻜﻨﻙ ﺘﻐﻴﻴﺭ ﺤﺠﻡ ﺍﻟﻤﺼﻔﻭﻓﺔ ﺩﻭﻥ ﺍﻟﻤﺨﺎﻁﺭﺓ ﺒﻔﻘﺩ ﺒﻴﺎﻨﺎﺘﻬـﺎ ﺒﺎﺴـﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤـﺔ ﺍﻟﻤﺤﺠـﻭﺯﺓ‬

‫‪ ،Preserve‬ﻭﻟﻜﻥ –ﻤﻊ ﺍﻻﺴﻑ ﺍﻟﺸﺩﻴﺩ - ﻻ ﻴﻤﻜﻥ ﺘﻐﻴﻴﺭ ﺍﻻ ﻋﺩﺩ ﻋﻨﺎﺼﺭ ﺍﻟﺒﻌـﺩ ﺍﻻﺨﻴـﺭ ﻓﻘـﻁ ﻓـﻲ ﻫـﺫﻩ‬
‫ﺍﻟﺤﺎﻟﺔ:‬
‫ﳑﻜﻦ ﺟﺪ ا '‬
‫)005( ‪ReDim Preserve OneDim‬‬
‫)005 ,01( ‪ReDim Preserve TwoDims‬‬
‫رﺳﺎﻟﺔ ﺧﻄ ﺄ '‬
‫)005 ,005( ‪ReDim Preserve TwoDims‬‬

‫ﻭﻤﻊ ﺍﻻﺴﻑ ﺍﻟﺸﺩﻴﺩ ﺍﻴﻀﺎ، ﻻ ﻴﻤﻜﻨﻙ ﺘﻐﻴﻴﺭ ﻋﺩﺩ ﺍﺒﻌﺎﺩ ﺍﻟﻤﺼﻔﻭﻓﺔ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴـﺔ ﺴـﻭﺍﺀ ﺍﺴـﺘﺨﺩﻤﺕ ‪Preserve‬‬
‫ﺍﻭ ﻟﻡ ﺘﺴﺘﺨﺩﻤﻬﺎ:‬
‫رﺳﺎﻟﺔ ﺧﻄ ﺄ '‬
‫)005 ,005( ‪ReDim Preserve OneDim‬‬
‫)001( ‪ReDim TwoDims‬‬

‫ﻓﻲ ﺍﻟﻤﻘﺎﺒل، ﺘﺴﺘﻁﻴﻊ ﺘﺩﻤﻴﺭ ﺍﻟﻤﺼﻔﻭﻓﺔ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴﺔ ﻟﺘﺤﺭﻴﺭ ﺍﻟﻤﺴـﺎﺤﺔ ﻓـﻲ ﺍﻟـﺫﺍﻜﺭﺓ ﻓـﻲ ﺍﻱ ﻭﻗـﺕ ﺘﺭﻴـﺩﻩ‬
‫ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻻﻤﺭ ‪:Erase‬‬
‫‪Erase OneDim‬‬
‫‪Erase TwoDims‬‬
‫85‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻋﻠﻰ ﺼﻌﻴﺩ ﺍﺨﺭ، ﺍﻟﻤﺼﻔﻭﻓﺎﺕ ﺘﻌﺘﺒﺭ ﻤﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ ‪ Reference Type‬ﻓـﻼ ﻴﻤﻜﻨـﻙ ﻨﺴـﺦ‬
‫ﻗﻴﻤﻬﺎ ﺒﺎﺴﺘﺨﺩﺍﻡ ﻤﻌﺎﻤل ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ "=". ﻟﻲ ﻋﻭﺩﺓ ﺤﻭل ﺍﻟﻤﺼﻔﻭﻓﺎﺕ ﻓﻲ ﺍﻟﻔﺼل ﺍﻟﺴﺎﺩﺱ ﺍﻟﻔﺌـﺎﺕ ﺍﻻﺴﺎﺴـﻴﺔ،‬

‫ﺍﻤﺎ ﺍﻻﻥ ﺩﻋﻨﻲ ﺍﻋﺭﺽ ﻟﻙ ﻜﻴﻑ ﻨﻨﺴﺦ ﻗﻴﻤﺔ ﻤﺼﻔﻭﻓﺔ ﺍﻟﻰ ﺍﺨﺭﻯ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻁﺭﻴﻘﺔ )(‪:Clone‬‬

‫}… ,3 ,2 ,1{ = ‪Dim X () As Integer‬‬
‫‪Dim Y () As Integer‬‬
‫ﻧﺴﺦ اﳌﺼﻔﻮ ﻓﺔ ‪ X‬ا ﱃ ‪' Y‬‬
‫)(‪Y = X.Clone‬‬

‫ﺍﻨﻬﻲ ﺤﺩﻴﺜﻲ ﻋﻥ ﺍﻟﻤﺼﻔﻭﻓﺎﺕ ﺒﺫﻜﺭ ﺍﻟﺩﺍﻟﺔ )(‪ UBound‬ﺍﻟﺘﻲ ﺘﻌﻭﺩ ﺒﺭﻗﻡ ﻓﻬـﺭﺱ ﺍﻟﻌﻨﺼـﺭ ﺍﻻﺨﻴـﺭ‬
‫ﻟﻠﻤﺼﻔﻭﻓﺔ، ﻭﺍﻟﺩﺍﻟﺔ )(‪ LBound‬ﺒﺭﻗﻡ ﺍﻟﻔﻬﺭﺱ ﻟﻠﻌﻨﺼﺭ ﺍﻻﻭل:‬
‫)‪For counter = LBound(OneDim) To UBound(OneDim‬‬
‫…‬
‫…‬
‫‪Next‬‬

‫ﻭﺒﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﺼﻔﻭﻓﺎﺕ ﺍﻟﻤﺘﻌﺩﺩﺓ ﺍﻻﺒﻌﺎﺩ، ﻴﺘﻭﺠﺏ ﻋﻠﻴﻙ ﺍﺭﺴﺎل ﺭﻗﻡ ﺍﻟﺒﻌﺩ ﺍﻟﺫﻱ ﺘﻭﺩ ﻤﻌﺭﻓﺔ ﻓﻬﺭﺴﺘﻪ:‬
‫اﻟﺒﻌ ﺪ اﻻو ل '‬
‫اﻟﺒﻌ ﺪ اﻻو ل '‬
‫اﻟﺒﻌ ﺪ اﻟﺜ ﺎﻧ ﻲ '‬

‫)‪UBound(OneDim‬‬
‫)1 ,‪UBound(OneDim‬‬
‫)2 ,‪UBound(OneDim‬‬

‫اﻻﺟﺮاءات واﻟﺪوال‬
‫ﻴﻤﻜﻨﻙ ‪ Visual Basic .NET‬ﻤﻥ ﺘﻌﺭﻴﻑ ﺍﻻﺠﺭﺍﺀﺍﺕ ﺍﻤـﺎ ﺒﺎﻟﻜﻠﻤـﺔ ﺍﻟﻤﺤﺠـﻭﺯﺓ ‪ Sub‬ﺍﻭ ‪،Function‬‬
‫ﺤﻴﺙ ﺍﻥ ﺍﺴﺘﺨﺩﺍﻤﻙ ﻟﻠﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ﺍﻟﺜﺎﻨﻴﺔ ﻴﺠﻌل ﺍﻻﺠﺭﺍﺀ ﻗﺎﺩﺭﺍ ﻋﻠﻰ ﺍﻟﻌﻭﺩﺓ ﺒﻘﻴﻤـﺔ ﻨﻭﻋﻬـﺎ ﺘﺤـﺩﺩﻩ ﻋﻨـﺩ‬

‫ﺘﻌﺭﻴﻑ ﺍﻻﺠﺭﺍﺀ:‬
‫اﺟﺮاء ﻻ ﻳﻌﻮد ﺑﻘﻴﻤ ﺔ '‬
‫)(‪Sub MySub‬‬
‫)"اﺟﺮاء ﻻ ﻳﻌﻮ د ﺑﻘﻴ ﻤ ﺔ"( ‪ArabicConsole.WriteLine‬‬
‫‪End Sub‬‬
‫داﻟﺔ ﺗﻌﻮ د ﺑﻘﻴ ﻤﺔ ﻣ ﻦ '‬
‫اﻟﻨﻮ ع ‪' Long‬‬
‫‪Function Abs (ByVal X As Integer) As Long‬‬
‫‪If X < 0 Then‬‬
‫‪Return -X‬‬
‫‪Else‬‬
‫‪Return X‬‬
‫‪End If‬‬
‫‪End Function‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫95‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻋﻨﺩ ﺍﺴﺘﺩﻋﺎﺀ ﺍﻻﺠﺭﺍﺀﺍﺕ، ﻋﻠﻴﻙ ﻜﺘﺎﺒﺔ ﺍﻻ ﻗﻭﺍﺱ ﺤﺘﻰ ﻟﻭ ﻟﻡ ﺘﻭﺠﺩ ﻭﺴﻴﻁﺎﺕ ‪ Parameters‬ﺘﺭﺴﻠﻬﺎ ﻟﻬﺎ:‬
‫ﺳﻴﻘﻮم اﶈ ﺮر ﺑﺎ ﺿﺎﻓﺔ اﻻﻗﻮا س ان ﱂ ﺗﻀﻔ ﻬ ﺎ '‬
‫)( ‪MySub‬‬
‫5 ' ))5-( ‪ArabicConsole.WriteLine (Abs‬‬

‫ﺘﺴﺘﻁﻴﻊ ﺍﻨﻬﺎﺀ ﺍﻻﺠﺭﺍﺀ ﻓﻲ ﺍﻱ ﻭﻗﺕ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻻﻤﺭ ‪ Exit Sub‬ﺍﻥ ﺘﻡ ﺍﻟﺘﻌﺭﻴـﻑ ﺒﺎﺴـﺘﺨﺩﺍﻡ ‪ Sub‬ﺍﻭ‬

‫‪ Exit Function‬ﺍﻥ ﺘﻡ ﺍﻟﺘﻌﺭﻴﻑ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪:Function‬‬

‫‪Function Abs (ByVal X As Integer) As Long‬‬
‫‪If X = 0 Then‬‬
‫‪Exit Function‬‬
‫‪End If‬‬
‫…‬
‫…‬
‫‪End Function‬‬

‫ﻣﻼﺣﻈﺔ‬
‫ان اﺳـﺘﺨﺪﻣﺖ اﻻﻣـﺮ ‪ Exit Function‬دون ﺗﻌﻴـﻴﻦ ﻗﻴﻤـﺔ ﻟﻠﺪاﻟـﺔ، ﻓﺴـﺘﻌﻮد‬
‫اﻟﺪاﻟﺔ ﺑﻘﻴﻤﺔ 0 ان آﺎﻧﺖ ﻋﺪدﻳﺔ، ﻻﺷـﺊ ان آﺎﻧـﺖ ﺣﺮﻓ ﻴـﺔ، او ‪ Nothing‬ان‬
‫آﺎﻧﺖ آﺎﺋﻨﻴﺔ..‬

‫ﻭﺒﺎﻟﻨﺴﺒﺔ ﻟﻘﺎﺒﻠﻴﺔ ﺍﻟﺭﺅﻴﺔ ﻓﻬﻲ ﺍﻤﺎ ﺘﻜﻭﻥ ‪ ،Private‬ﺍﻭ ‪ ،Friend‬ﺍﻭ ‪ Public‬ﻜﺎﻟﻤﺘﻐﻴﺭﺍﺕ.‬

‫اﻻرﺳﺎل ﺑﺎﻟﻤﺮﺟﻊ او اﻟﻘﻴﻤﺔ‬

‫ﺒﺸﻜل ﺍﻓﺘﺭﺍﻀﻲ، ﺍﻟﻭﺴﻴﻁﺎﺕ ﺍﻟﺘﻲ ﻴﺴﺘﻘﺒﻠﻬﺎ ﺍﻻﺠـﺭﺍﺀ ﻫـﻲ ﻤﺘﻐﻴـﺭﺍﺕ ﺍﺭﺴـﻠﺕ ﺒﺎﻟﻘﻴﻤـﺔ، ﻭﺍﻥ ﺍﺭﺩﺕ ﻤـﻥ‬
‫ﺍﺠﺭﺍﺀﺍﺘﻙ ﺍﻥ ﺘﺴﺘﻘﺒل ﻗﻴﻤﻬﺎ ﺒﺎﻟﻤﺭﺠﻊ ﺤﻴﺙ ﻴﻤﻜﻨـﻙ ﺘﻌـﺩﻴل ﻗـﻴﻡ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺍﻟﻤﺭﺴـﻠﺔ، ﺍﺴـﺘﺨﺩﻡ ﺍﻟﻜﻠﻤـﺔ‬

‫ﺍﻟﻤﺤﺠﻭﺯﺓ ‪:ByRef‬‬

‫هﻨﺎ ﺑﺎﻟﻘ ﻴﻤﺔ و ﻟﻦ ﺗﺘ ﺄﺛﺮ ا ﳌﺘﻐﲑا ت اﳌﺮ ﺳﻠ ﺔ '‬
‫)‪Sub swapByVal(ByVal a As Integer, ByVal b As Integer‬‬
‫‪Dim temp As Integer‬‬
‫‪temp = a‬‬
‫‪a = b‬‬
‫‪b = temp‬‬
‫‪End Sub‬‬
‫اﻣﺎ هﻨﺎ ﺑﺎﳌﺮﺟ ﻊ وﺳﺘ ﺘﺄﺛﺮ اﳌﺘﻐﲑ ات اﳌ ﺮﺳﻠ ﺔ '‬
‫)‪Sub swapByRef(ByRef a As Integer, ByRef b As Integer‬‬
‫‪Dim temp As Integer‬‬
‫‪temp = a‬‬
‫‪a = b‬‬
‫‪b = temp‬‬
‫‪End Sub‬‬
‫06‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻴﺘﻀﺢ ﺍﻟﻔﺭﻕ ﻓﻲ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ:‬
‫‪Dim A As Integer‬‬
‫‪Dim B As Integer‬‬
‫01 = ‪A‬‬
‫02 = ‪B‬‬
‫ارﺳﺎل ﺑﺎ ﻟﻘﻴﻤ ﺔ '‬
‫)‪swapByVal (A, B‬‬
‫01 ' )‪ArabicConsole.WriteLine (A‬‬
‫02 ' )‪ArabicConsole.WriteLine (B‬‬
‫ارﺳﺎل ﺑﺎ ﳌﺮﺟ ﻊ '‬
‫)‪swapByRef (A, B‬‬
‫02 ' )‪ArabicConsole.WriteLine (A‬‬
‫01 ' )‪ArabicConsole.WriteLine (B‬‬

‫ﻭﻟﻠﺤﺩﻴﺙ ﻋﻥ ﺍﻟﻤﺴﺎﺌل ﺍﻟﺘﻘﻨﻴﺔ، ﺴﺄﺒﺩﺍ ﺒﻌﻤﻠﻴﺔ ﺍﺭﺴﺎل ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺒﺎﻟﻘﻴﻤـﺔ، ﻓﻬـﻲ ﺍﺒﻁـﺄ ﻤـﻥ ﺍﻻﺭﺴـﺎل‬
‫ﺒﺎﻟﻤﺭﺠﻊ ﻭﺫﻟﻙ ﻻﻨﻪ ﺴﻴﺘﻡ ﺍﻨﺸﺎﺀ ﻨﺴﺨﺔ ﻤﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﺭﺴﻠﺔ ﻓﻲ ﻜل ﻤـﺭﺓ ﺘﺴـﺘﺩﻋﻲ ﺍﻻﺠـﺭﺍﺀ. ﻤـﻥ ﻨﺎﺤﻴـﺔ‬
‫ﺍﺨﺭﻯ، ﺘﻭﺠﺩ ﻤﻴﺯﺓ ﻓﻲ ﻋﻤﻠﻴﺔ ﺍﺭﺴﺎل ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺒﺎﻟﻘﻴﻤﺔ، ﻭﻫﻲ ﻋﺩﻡ ﺍﻟﺘﺄﺜﻴﺭ ﻋﻠﻰ ﺒﺎﻗﻲ ﺍﺠـﺯﺍﺀ ﺍﻟﺒﺭﻨـﺎﻤﺞ ﺍﻥ‬
‫ﻗﻤﺕ ﺒﺘﻌﺩﻴل ﻗﻴﻤﻬﺎ ﺒﻁﺭﻴﻕ ﺍﻟﺨﻁﺄ. ﺍﻤﺎ ﺍﻻﺭﺴﺎل ﺒﺎﻟﻤﺭﺠﻊ، –ﻜﻤﺎ ﻗﻠﺕ ﻗﺒل ﻗﻠﻴل - ﻫﻭ ﺍﺴـﺭﻉ ﻤـﻥ ﺍﻻﺭﺴـﺎل‬

‫ﺒﺎﻟﻘﻴﻤﺔ، ﻓﺎﻨﺕ ﺘﺭﺴل ﻤﺅﺸﺭ ﻟﻠﻤﺘﻐﻴﺭ ﻤﻤﺎ ﻴﻤﻜﻨﻙ ﻤﻥ ﺘﻌﺩﻴل ﻗﻴﻤﺔ ﺍﻟﻤﺘﻐﻴﺭ ﺍﻟﻤﺭﺴل.‬
‫ﻣﻼﺣﻈﺔ‬

‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﺘﻐﻴﺮات اﻟﻤﺮﺟﻌﻴﺔ ‪ Reference Ty pe Variables‬اﻟﻤﺮﺳﻠﺔ اﻟﻰ‬
‫اﻻﺟﺮاءات، ﺳﺘﺘﺄﺛﺮ ﺑﺎﻟﺘﻐﻴﻴﺮات ﺣﺘﻰ وان ارﺳـﻠﺖ ﺑﺎﻟﻘﻴﻤـﺔ، اي ﺑﺎﺳـﺘﺨﺪام‬
‫اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪.By Val‬‬

‫ﺗﺨﺼﻴﺺ اﻟﻮﺳﻴﻄﺎت اﻟﻤﺮﺳﻠﺔ‬
‫ﺍﻟﻤﺯﻴﺩ ﻤﻥ ﺍﻟﺘﺨﺼﻴﺹ ﺤﻭل ﺍﻟﻭﺴﻴﻁﺎﺕ ﻴﻭﻓﺭﻩ ﻟﻙ ‪ ،Visual Basic .NET‬ﺍﺫ ﻴﻤﻜﻨﻙ ﻤﻥ ﺍﻟﺘﺼـﺭﻴﺢ ﻋـﻥ‬
‫ﺍﻟﻭﺴﻴﻁﺎﺕ ﺍﻻﺨﺘﻴﺎﺭﻴﺔ ‪ Optional‬ﻭﺍﻟﻐﻴﺭ ﻤﺤﺩﻭﺩﺓ ﺍﻟﻌﺩﺩ ‪.ParamArray‬‬

‫ﺍﻟﻭﺴﻴﻁﺎﺕ ﺍﻻﺨﺘﻴﺎﺭﻴﺔ:‬
‫ﺍﺤﻴﺎﻨﺎ ﺘﻭﺩ ﻤﻥ ﺍﺠﺭﺍﺀﺍﺘﻙ ﺍﻥ ﺘﻜﻭﻥ ﻤﺭﻨﺔ ﺒﻤﺎ ﻓﻴﻪ ﺍﻟﻜﻔﺎﻴﺔ ﺒﺤﺙ ﻻ ﺘﺸﺘﺭﻁ ﺘﻭﺍﻓﻕ ﻋـﺩﺩ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺍﻟﻤﺭﺴـﻠﺔ‬
‫ﻤﻊ ﻋﺩﺩ ﻭﺴﻴﻁﺎﺕ ﺍﻻﺠﺭﺍﺀ، ﺘﺴﺘﻁﻴﻊ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Optional‬ﻗﺒل ﻜل ﻭﺴﻴﻁﺔ ﺍﺨﺘﻴﺎﺭﻴـﺔ ﻤـﻊ‬

‫ﻀﺭﻭﺭﺓ ﺘﺤﺩﻴﺩ ﻗﻴﻤﺔ ﺍﻓﺘﺭﺍﻀﻴﺔ ﻟﻬﺎ ﻓﻲ ﺤﺎﻟﺔ ﻋﺩﻡ ﺍﺭﺴﺎل ﻗﻴﻤﺔ ﻟﻼﺠﺭﺍﺀ:‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫16‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬
‫)1- = ‪Sub MySub(Optional ByVal X As Integer‬‬
‫‪If X = -1 Then‬‬
‫)"ﱂ ﺗﺮﺳ ﻞ ﻗﻴﻤ ﺔ"( ‪ArabicConsole.WriteLine‬‬
‫‪End If‬‬
‫…‬
‫…‬
‫‪End Sub‬‬

‫ﻨﻘﻁﺔ ﺍﺨﺭﻯ، ﻻ ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠـﻭﺯﺓ ‪ Optional‬ﺍﻻ ﻓـﻲ ﺍﻟﻭﺴـﻴﻁﺎﺕ ﺍﻻﺨﻴـﺭﺓ )ﺍﻱ‬
‫ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺠﻬﺔ ﺍﻟﻴﻤﻴﻥ( ﻓﻼ ﻴﻤﻜﻥ ﻟﻭﺴﻴﻁﺔ ﺍﺨﺘﻴﺎﺭﻴﺔ ﺍﻥ ﺘﺴﺒﻕ ﻭﺴﻴﻁﺔ ﻋﺎﺩﻴﺔ:‬
‫هﻜﺬا ﳑﻜ ﻦ '‬
‫)1- = ‪Sub MySub(ByVal Y As Byte, Optional ByVal X As Integer‬‬
‫…‬
‫…‬
‫‪End Sub‬‬
‫اﻧﺴﻰ هﺬﻩ اﻟﻔﻜ ﺮ ة '‬
‫)‪Sub MySub(Optional ByVal X As Integer = -1, ByVal Y As Byte‬‬
‫…‬
‫…‬
‫‪End Sub‬‬

‫ﺍﻟﻭﺴﻴﻁﺎﺕ ﻏﻴﺭ ﻤﺤﺩﻭﺩﺓ ﺍﻟﻌﺩﺩ:‬

‫ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﻓﺎﻨﻙ ﻻ ﺘﺤﺩﺩ ﻋﺩﺩﺍ ﻤﻌﻴﻨﺎ ﻟﻠﻭﺴﻴﻁﺎﺕ ﺍﻟﺘﻲ ﻴﺴﺘﻘﺒﻠﻬﺎ ﺍﻻﺠﺭﺍﺀ، ﻻﻥ ﺍﻟﻘﻴﻡ ﺴﺘﺭﺴـل ﻭﺘﺤﻔـﻅ ﻓـﻲ‬

‫ﻤﺼﻔﻭﻓﺔ ﺘﻌﺭﻓﻬﺎ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪:ParamArray‬‬
‫‪Function Sum(ByVal ParamArray Nums() As Integer) As Integer‬‬
‫‪Dim counter As Integer‬‬
‫)‪For counter = 0 To UBound(Nums‬‬
‫)‪Sum += Nums(counter‬‬
‫‪Next‬‬
‫‪End Function‬‬

‫ﺘﻁﺒﻴ ﻘﻴﺎ، ﻜل ﻫﺫﻩ ﺍﻻﺴﺘﺩﻋﺎﺀﺍﺕ ﺼﺤﻴﺤﺔ ﺒﺎﺴﺘﺜﻨﺎﺀ ﺍﻻﺨﻴﺭﺓ ﺍﻟﺫﻱ ﻴﺘﻭﻗﻊ ﺍﻨﻪ ﺍﺨﺘﻴﺎﺭﻱ:‬
‫1 '‬
‫4 '‬
‫51 '‬

‫) )1( ‪ArabicConsole.WriteLine ( Sum‬‬
‫) )2 ,2( ‪ArabicConsole.WriteLine ( Sum‬‬
‫) )5 ,4 ,3 ,2 ,1( ‪ArabicConsole.WriteLine ( Sum‬‬
‫ﺧﻄﺄ هﻨ ﺎ '‬
‫) )3 , ,1( ‪ArabicConsole.WriteLine ( Sum‬‬

‫ﺗﺠﺎوز اﻟﺤﺪود ﻣﻊ ‪Windows API‬‬
‫ﺍﻥ ﻜﻨﺕ ﻻ ﺘﻌﺭﻑ ﻤﺎ ﻫﻲ ﺍﺠﺭﺍﺀﺍﺕ ‪ ،Windows API‬ﻓﺎﻋﺘﺒﺭ ﻨﻔﺴﻙ ﻤﺒﺭﻤﺞ ﻤﺤﻅﻭﻅ ﺠـﺩﺍ! ﻭﺒﻤـﺎ ﺍﻨﻨـﻲ‬
‫ﻟﺴﺕ ﻤﻥ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺍﻟﺸﺠﻌﺎﻥ، ﻓﻠﻥ ﺍﺘﺤﺩﺙ ﻋﻨﻬﺎ. ﺍﻤﺎ ﺍﻥ ﻜﻨﺕ ﻤـﻥ ﻤﺒﺭﻤﺠـﻲ ‪ Windows‬ﺍﻟﻤﺨﻀـﺭﻤﻴﻥ،‬
‫ﻓﺘﺴﺘﻁﻴﻊ ﺍﻟﺘﺼﺭﻴﺢ ﻋـﻥ ﺍﺠـﺭﺍﺀﺍﺕ ‪ Windows API‬ﻟﻠﺘﺠـﺎﻭﺯ ﺤـﺩﻭﺩ ﻋـﺎﻟﻡ ﺍﻁـﺎﺭ ﻋﻤـل ‪.NET‬‬

‫‪ .Framework‬ﻟﻌﻤل ﺫﻟﻙ، ﺼﺭﺡ ﻋﻥ ﺍﻻﺠﺭﺍﺀ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠـﻭﺯﺓ ‪ Declare‬ﻤـﻊ ﺘﺤﺩﻴـﺩ ﻨـﻭﻉ‬
‫26‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺼﻔﺤﺔ ﺍﻟﻤﺤﺎﺭﻑ ﺍﻤﺎ ‪ ،Unicode ،Ansi‬ﺍﻭ ‪ .Auto‬ﺍﻥ ﺍﺴﺘﺨﺩﻤﺕ ‪ ،Auto‬ﺴﻴﺘﻡ ﺘﺤﻭﻴـل ﺍﻟﺤـﺭﻭﻑ ﺍﻟـﻰ‬
‫‪ Unicode‬ﺘﺤﺕ ﺠﻤﻴﻊ ﺍﻻﻨﻅﻤﺔ ﺒﺎﺴـﺘﺜﻨﺎﺀ 89 ‪ Windows‬ﻭ ‪ Windows ME‬ﺤﻴـﺙ ﺴـﺘﺘﺤﻭل ﺍﻟـﻰ‬
‫‪:Ansi‬‬

‫1‪Module Module‬‬
‫_ ‪Declare Auto Function GetUserName Lib "advapi32.dll" Alias‬‬
‫_ ,‪"GetUserNameA" (ByVal lpBuffer As String‬‬
‫‪ByRef nSize As Integer) As Integer‬‬
‫)( ‪Sub Main‬‬
‫…‬
‫…‬
‫)‪GetUserName (x, y‬‬
‫‪End Sub‬‬
‫‪End Module‬‬

‫اﻟﺘﻔﺮع واﻟﺘﻜﺮار‬
‫ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺎﺕ ﻤﻥ ﺍﻟﺼﻌﺏ ﺘﻁﺒﻴﻘﻬﺎ ﺒﺭﻤﺠﻴﺎ ﺩﻭﻥ ﺍﺴﺘﺨﺩﺍﻤﻙ ﻟﺠﻤل ﺍﻟﺘﻔﺭﻉ ﻭﺤﻠﻘﺎﺕ ﺍﻟﺘﻜﺭﺍﺭ. ﻓﻲ ﻫـﺫﺍ ﺍﻟﻘﺴـﻡ‬
‫ﻤﻥ ﺍﻟﻔﺼل ﺴﻨﺘﻭﻏل ﻓﻲ ﻋﺒﺎﺭﺍﺕ ﺍﻟﺘﻔﺭﻉ ‪ If … Then‬ﻭ ‪ ،Select Case‬ﻜﻤﺎ ﺴـﺄﺘﻁﺭﻕ ﺍﻟـﻰ ﺍﻟﺤﻠﻘـﺎﺕ‬

‫ﺍﻟﺘﻜﺭﺍﺭﻴﺔ ﺍﻟﻤﺨﺘﻠﻔﺔ ﺍﻟﻤﺘﻭﻓﺭﺓ ﻓﻲ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ‪.Visual Basic .NET‬‬

‫اﻟﺘﻔﺮع ﺑﺎﺳﺘﺨﺪام ‪If … Then‬‬
‫ﺍﺴﺘﺨﺩﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ If‬ﻟﺘﻀﻴﻑ ﺍﻟﻴﻬﺎ ﺠﻤﻠﺔ ﺸﺭﻁﻴﺔ ﺜـﻡ ﺘﻠﺤﻘﻬـﺎ ﺒﻜﻠﻤـﺔ ‪ ،Then‬ﻭﻻ ﺘﻨﺴـﻰ ﺍﺴـﺘﺨﺩﺍﻡ‬
‫‪ End If‬ﺍﻥ ﻭﺯﻋﺕ ﺍﻭﺍﻤﺭ ﺍﻟﺸﺭﻁ ﻓﻲ ﺍﻜﺜﺭ ﻤﻥ ﺴﻁﺭ )ﻭﻫﻭ ﺍﻟﻤﻔﻀل(:‬
‫ﰲ ﺳﻄﺮ وا ﺣ ﺪ '‬
‫1 = ‪If X = 0 Then Y‬‬
‫4 = ‪If X = 1 Then X = 2 : Y‬‬
‫2 = ‪If Y = 1 Then X = 0 Else X‬‬
‫ﻳﻔﻀﻞ ﺗﻮز ﻳﻌﻬﺎ هﻜﺬ ا '‬
‫‪If X = 0 Then‬‬
‫1 = ‪Y‬‬
‫‪End If‬‬
‫‪If X = 1 Then‬‬
‫0 = ‪X‬‬
‫4 = ‪Y‬‬
‫‪End If‬‬
‫‪If Y = 1 Then‬‬
‫0 = ‪X‬‬
‫‪Else‬‬
‫2 = ‪X‬‬
‫‪End If‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫36‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻣﻼﺣﻈﺔ‬
‫اﻟﻤﻌﺎﻣﻞ ":" ﻋﻜﺲ اﻟﻤﻌﺎﻣﻞ "_" ﺑﺤﻴﺚ ﻳﻤﻜﻨـﻚ ﻣـﻦ دﻣـﺞ ﻋـﺪة اواﻣـﺮ ﻓـﻲ‬
‫ﺳﻄﺮ واﺣﺪ.‬

‫ﺫﻜﺭﺕ ﻤﺭﺘﻴﻥ ﺍﻥ ﺍﻟﻤ ﻔﻀل ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺼﻴﻐﺔ ﺍﻟﻤﻭﺯﻋﺔ ﻭﺍﻏﻼﻗﻬﺎ ﺒـ ‪ End If‬ﺤﻴﺙ ﺍﻨﻬﺎ ﺘﺴـﻬل ﻋﻠﻴـﻙ‬

‫ﻗﺭﺍﺀﺓ ﻭﻓﻬﻡ ﻤﻨﻁﻕ ﺍﻟﺘﻔﺭﻉ ﺨﺎﺼﺔ ﺍﻥ ﻜﺎﻨﺕ ﺠﻤل ﺍﻟﺸﺭﻁ ﻤﺘﺩﺍﺨﻠﺔ، ﺭﻜﺯ ﻤﻌﻲ ﻴﺎ ﺤﻠﻭ ﻓﻲ ﻫﺫﻩ ﺍﻟﺠﻤل:‬

‫‪If X = 0 Then‬‬
‫‪If Y = 0 Then‬‬
‫001 = ‪X‬‬
‫‪End If‬‬
‫‪Else‬‬
‫1 = ‪Y‬‬
‫‪End If‬‬

‫ﻗﺩ ﻴﺄﺘﻲ ﺸﺨﺹ ﻤﺼﻤﻡ ﻋﻠﻰ ﺍﺨﺘﺼﺎﺭ ﺍﻟﺠﻤل ﺍﻟﺴﺎﺒﻘﺔ ﻓﻲ ﺴﻁﺭ ﺍﻟﻭﺍﺤﺩ ) ﻓﻬﻭ ﻤﺒﺭﻤﺞ ﻤﺤﺘـﺭﻑ ﻜﻤـﺎ ﻴـﺩﻋﻲ(‬

‫ﻭﻴﻜﺘﺏ ﺸﻴﺌﺎ ﻤﺜل:‬

‫1 = ‪If X = 0 Then If Y = 0 Then X = 100 Else Y‬‬

‫ﺍﻨﺼﺤﻙ ﺒﻌﺩﻡ ﺍﻻﺴﺘﻤﺎﻉ ﻟﻪ ﻤﺎﺩﺍﻡ ﺍﻟﺤﻤﺎﻡ ﻴﻐﺭﺩ! ﻓﻤﻨﻁﻕ ﺍﻟﺘﻔﺭﻉ ﻓﻲ ﺠﻤﻠﺔ ﺍﺨﻴﻨـﺎ ﻓـﻲ ﺍﷲ ﺨﺎﻁﺌـﺔ، ﺤﻴـﺙ ﺍﻥ‬
‫ﻜﻠﻤﺔ ‪ Else‬ﺍﻻﺨﻴﺭﺓ ﺘﺘﺒﻊ ﻟﻠﺸﺭﻁ ﺍﻟﺜﺎﻨﻲ ﻭﻟﻴﺱ ﺍﻻﻭل، ﺍﻱ ﺍﻥ ‪ Visual Basic .NET‬ﺴﻴﻔﻬﻤﻬﺎ ﻋﻠﻰ ﺍﻨﻬﺎ:‬

‫‪If X = 0 Then‬‬
‫‪If Y = 0 Then‬‬
‫001 = ‪X‬‬
‫‪Else‬‬
‫1 = ‪Y‬‬
‫‪End If‬‬
‫‪End If‬‬

‫ﻭﺤﺘﻰ ﻻ ﻨﻀﻴﻊ ﻭﻗﺘﻨﺎ ﺍﻟﺜﻤﻴﻥ ﻓﻲ ﻤﺜل ﻫﺫﻩ ﺍﻟﺴﺠﺎﻻﺕ، ﺴﺎﻏﻠﻕ ﺍﻟﻤﻭﻀﻭﻉ ﺒﻨﺼﻴﺤﺔ: ﺍﺴـﺘﺨﺩﻡ ﺍﻟﺼـﻴﻐﺔ‬

‫ﺍﻟﻤﻔﺭﻗﺔ ‪ If … Then … End If‬ﺩﺍﺌﻤﺎ ﺤﺘﻰ ﻟﻭ ﻜﺎﻥ ﺠﻭﺍﺏ ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﺃﻤﺭ ﻭﺍﺤﺩ ﻓﻘﻁ.‬
‫ﺍﺩﻭﺍﺕ ﺍﻟﺭﺒﻁ ﺍﻟﻤﻨﻁﻘﻲ:‬

‫ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﺩﻭﺍﺕ ﺍﻟﺭﺒﻁ ﺍﻟﻤﻨﻁﻘﻲ ) ‪... Not ،Or ،And‬ﺍﻟﺦ( ﺒﻁﻼﻗﺔ ﻜﺎﻤﻠﺔ ﻜﻤـﺎ ﺘﻔﻌـل ﻤـﻊ ﻟﻐـﺎﺕ‬
‫ﺍﻟﺒﺭﻤﺠﺔ ﺍﻻﺨﺭﻯ، ﺤﻴﺙ ﺍﻨﻬﺎ ﻤﺩﻋﻭﻤﺔ ﻓﻲ ‪:Visual Basic .NET‬‬
‫‪If x > 0 And t < 1 Then‬‬
‫…‬
‫…‬
‫‪End If‬‬
‫… ‪If Not Y > 1 Then‬‬
‫46‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺩﻋﻨﺎ ﻨﻠﻬﻭ ﻗﻠﻴﻼ ﻓﻲ ﻋﻠﻡ ﺍﻟﻤﻨﻁﻕ ﺍﻟﺭﻴﺎﻀﻲ، ﻭﺍﻁﻠﺏ ﻤﻨﻙ ﺍﻟﺘﺭﻜﻴﺯ ﻓﻲ ﺍﻟﺸﺭﻁ ﺍﻟﺘﺎﻟﻲ:‬
‫‪If X <> 0 And 10  X = 2 Then‬‬

‫ﻟﻐﻭﻴﺎ، ﺍﻟﺸﺭﻁ ﺍﻟﺴﺎﺒﻕ ﻴﺨﺘﺒﺭ ﻗﻴﻤﺔ ﺍﻟﻤﺘﻐﻴﺭ ‪ X‬ﻤﺎ ﺍﺫﺍ ﻜﺎﻨـﺕ ﺘﺴـﺎﻭﻱ ﺍﻟﺼـﻔﺭ ﺍﻡ ﻻ، ﻭﺍﻥ ﻜﺎﻨـﺕ ﻻ ﺘﺴـﺎﻭﻱ‬

‫ﺼﻔﺭ ﻓﺴﺘﺨﺘﺒﺭ ﻨﺎﺘﺞ ﺍﻟﻘﺴﻤﺔ. ﻤﻊ ﺫﻟﻙ، ﻓﺈﻥ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ ﺴﺘﻅﻬﺭ ﺭﺴﺎﻟﺔ ﺨﻁﺄ ﺍﻥ ﻜﺎﻨﺕ ﻗﻴﻤـﺔ ﺍﻟﻤﺘﻐﻴـﺭ ‪X‬‬
‫ﺘﺴﺎﻭﻱ ﺼﻔﺭ، ﻭﺍﻟﺴﺒﺏ ﺍﻥ ‪ Visual Basic .NET‬ﺴﻴﺠﺭﻱ ﻋﻤﻠﻴﺔ ﺍﻟﻘﺴﻤﺔ ﺩﺍﺌﻤﺎ. ﻤﻨﻁﻘﻴـﺎ، ﻴﻔﺘـﺭﺽ ﻤـﻥ‬
‫‪ Visual Basic .NET‬ﺍﻥ ﻻ ﻴﺘﻌﺏ ﻨﻔﺴﻪ ﻭﻴﺠﺭﻱ ﻋﻤﻠﻴﺔ ﺍﻟﻘﺴﻤﺔ ﺍﻥ ﻜﺎﻨـﺕ ﻗﻴﻤـﺔ ﺍﻟﻤﺘﻐﻴـﺭ ‪ X‬ﺘﺴـﺎﻭﻱ‬

‫ﺼﻔﺭ، ﻭﺍﻟﺴﺒﺏ ﺍﻥ ﺍﻟﻌﺒﺎﺭﺓ ﺴﺘﻜﻭﻥ ﺩﺍﺌﻤﺎ ‪) False‬ﺨﺎﻁﺌﺔ(. ﺘﻘﻨﻴﺎ، ﺍﻟﻤﻌﺎﻤل ‪ And‬ﻴﻘﻭﻡ ﺒﺎﺨﺘﺒﺎﺭ ﺠﻤﻴـﻊ ﺍﻟﺠﻤـل‬
‫ﺍﻟﺸﺭﻁﻴﺔ ﺍﻟﺘﻲ ﺤﻭﻟﻪ، ﻟﺫﻟﻙ ﻴﻨﺼﺢ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﻌﺎﻤل ‪ AndAlso‬ﻓﻲ ﻤﺜل ﻫﺫﻩ ﺍﻟﺤﺎﻻﺕ:‬

‫‪If X <> 0 AndAlso 10  X = 2 Then‬‬

‫ﺍﻥ ﻜﺎﻨﺕ ﻗﻴﻤﺔ ﺍﻟﻤﺘﻐﻴﺭ ‪ X‬ﻓﻲ ﺍﻟﺠﻤﻠﺔ ﺍﻟﺴﺎﺒﻘﺔ ﺘﺴﺎﻭﻱ ﺼﻔﺭ، ﻓﺎﻥ ‪ Visual Basic .NET‬ﻟﻥ ﻴﻜﻤل ﻋﻤﻠﻴـﺔ‬
‫ﺍﻟﺘﺤﻘﻕ ﻤﻥ ﻋﻤﻠﻴﺔ ﺍﻟﻘﺴﻤﺔ ﻤﻤﺎ ﻴﺠﻨﺒﻨﺎ ﻅﻬﻭﺭ ﺭﺴﺎﻟﺔ ﺍﻟﺨﻁﺄ.‬

‫ﺍﻟﻰ ﺠﺎﻨﺏ ﺍﻟﻤﻌﺎﻤل ‪ AndAlso‬ﻴﻭﺠﺩ ﻤﻌﺎﻤل ﺍﺨﺭ ﻫﻭ ‪ OrElse‬ﻭﺍﻟﺫﻱ ﺴﻴﺘﺨﻁﻰ ﺍﻟﺸـﺭﻁ ﺍﻟﺜـﺎﻨﻲ ﺍﻥ‬

‫ﻜﺎﻥ ﺍﻻﻭل ‪:True‬‬

‫ﻟﻦ ﻳﺘﻢ ا ﻟﺘﺤﻘﻖ ﻣﻦ ا ﻟﺸﺮط اﻟﺜﺎﻧ ﻲ '‬
‫ان آﺎ ن اﻟﻌ ﺪد ﰲ اﳌﺘﻐ ﲑ ‪' X‬‬
‫ﻣﻮﺟﺐ '‬
‫… ‪If X > 0 OrElse Y < 0 Then‬‬

‫ﻋﻠﻴﻙ ﻤﻌﺭﻓﺔ ﺍﻥ ﺍﻟﻤﻌـﺎﻤﻼﺕ ‪ AndAlso‬ﻭ ‪ OrElse‬ﺘﺘﻌﺎﻤـل ﻤـﻊ ﺍﻟﻘـﻴﻡ ﺍﻟﻤﻨﻁﻘﻴـﺔ ﻓﻘـﻁ، ﻭﺍﻥ‬

‫ﺍﺴﺘﺨﺩﻤﺕ ﺍﻻﻋﺩﺍﺩ )ﺴﺘﺠﺭﻯ ﻋﻤﻠﻴﺔ ﺍﻟﺘﺤﻭﻴل ﺍﻟﺘﻠﻘﺎﺌﻲ ﻓﻲ ﺤﺎﻟـﺔ ‪ (Option Strict Off‬ﻓﺴـﺘﻌﺘﺒﺭ ﺍﻱ ﻗﻴﻤـﺔ‬
‫ﻏﻴﺭ ﺍﻟﺼﻔﺭ ‪ ،True‬ﺒﻴﻨﻤﺎ ﺍﻟﻤﻌﺎﻤﻼﺕ ‪ And‬ﻭ ‪ Or‬ﺘﺨﺘﺒﺭ ﺍﻟﺒﺘﺎﺕ ﺍﻟﺘـﻲ ﺘﻜـﻭﻥ ﺍﻟﻌـﺩﺩ –ﻟـﺫﻟﻙ ﺘﺴـﻤﻰ -‪bit‬‬
‫‪ ،wise operators‬ﻓﺠﻤﻠﺔ ﺍﻟﺸﺭﻁ ﺍﻟﺘﺎﻟﻴﺔ:‬

‫3 = ‪x‬‬
‫21 = ‪y‬‬
‫‪If x <> 0 And y <> 0 Then … ' True‬‬

‫ﻴﻤﻜﻨﻙ ﺍﺨﺘﺼﺎﺭﻫﺎ ﺒﺎﻟﻤﻌﺎﻤل ‪ AndAlso‬ﻟﺘﻌﻁﻲ ﻨﺘﻴﺠﺔ ﻤﻤﺎﺜﻠﺔ:‬
‫ﻋﻤﻠﻴﺔ اﳌ ﻘﺎﻧﺔ ﲣﺘﱪ ا ﻟﻘﻴ ﻢ '‬
‫‪' True And True = True‬‬
‫… ‪If x AndAlso y Then‬‬

‫ﺒﻴﻨﻤﺎ ﻴﺅﺩﻱ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﻌﺎﻤل ‪ And‬ﺍﻟﻰ ﺍﺨﺘﺒﺎﺭ ﺍﻟﺒﺘﺎﺕ ﺍﻟﻤﻜﻭﻨﺔ ﻟﻼﻋﺩﺍﺩ، ﻟﺘﻌﻁﻲ ﻨﺘﻴﺠﺔ ﺨﺎﻁﺌﺔ:‬
‫ﻋﻤﻠﻴﺔ اﳌ ﻘﺎرﻧﺔ ﲣﺘﱪ اﻟﺒﺘﺎ ت '‬
‫)‪' 0011 And 1100 = 0000 (False‬‬
‫… ‪If x And y Then‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫56‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺍﺨﻴﺭﺍ، ﻴﻤﻜﻨﻙ ﺍﺨﺘﺒﺎﺭ ﻤﺠﻤﻭﻋﺔ ﺠﻤل ﺸﺭﻁﻴﺔ ﻭﺘﻨﻔﻴـﺫ ﺍﻭﺍﻤـﺭ ﻤﻌﻴﻨـﻪ ﺍﻥ ﺍﺨﻔﻘـﺕ ﻜﻠﻬـﺎ ﺒﺎﺴـﺘﺨﺩﺍﻡ‬
‫‪:ElseIf‬‬
‫‪If X = 1 Then‬‬
‫…‬
‫‪ElseIf X = 2 Then‬‬
‫…‬
‫‪ElseIf X = 3 Then‬‬
‫…‬
‫‪Else‬‬
‫…‬
‫‪End If‬‬

‫اﻟﺘﻔﺮع ﺑﺎﺳﺘﺨﺪام ‪Select Case‬‬

‫ﺍﻟﺘﻔﺭﻉ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪ Select Case‬ﻴﻤﻜﻥ ﺘﻁﺒﻴﻘﻪ ﺒﺴﻬﻭﻟﺔ ﺘﺎﻤﺔ:‬

‫)"ﳏﺮ م"(‬
‫)"ﺻﻔ ﺮ"(‬

‫)"ذو اﳊ ﺠ ﺔ"(‬
‫)"ﻏﲑ ﻣﻌ ﺮ ف"(‬

‫‪Dim X As Integer‬‬
‫…‬
‫…‬
‫‪Select Case X‬‬
‫1 ‪Case‬‬
‫‪ArabicConsole.WriteLine‬‬
‫2 ‪Case‬‬
‫‪ArabicConsole.WriteLine‬‬
‫…‬
‫…‬
‫21 ‪Case‬‬
‫‪ArabicConsole.WriteLine‬‬
‫‪Case Else‬‬
‫‪ArabicConsole.WriteLine‬‬
‫‪End Select‬‬

‫ﺘﻜﻤﻥ ﻗﻭﺓ ﺍﻟﻌﺒﺎﺭﺓ ‪ Select Case‬ﻓﻲ ﺘﻁﺒﻴﻕ ﺍﻟﻤﻌﺎﻤﻼﺕ ﺍﻟﻤﻨﻁﻘﻴﺔ ﺍﻭ ﺘﺤﺩﻴﺩ ﻤﺠﺎﻻﺕ ﻟﻠﻘﻴﻡ ﺍﻟﻤﻁﻠـﻭﺏ‬

‫ﺍﻟﺘﺤﻘﻕ ﻤﻨﻬﺎ:‬

‫)"راﺳ ﺐ"(‬
‫)"ﻣﻘﺒﻮ ل"(‬
‫)"ﺟﻴ ﺪ"(‬
‫)"ﺟﻴﺪ ﺟ ﺪ ا"(‬
‫)"ﳑﺘﺎ ز"(‬

‫‪Dim Grade As Integer‬‬
‫…‬
‫…‬
‫‪Select Case Grade‬‬
‫06 < ‪Case Is‬‬
‫‪ArabicConsole.WriteLine‬‬
‫96 ‪Case 60 To‬‬
‫‪ArabicConsole.WriteLine‬‬
‫97 ‪Case 70 To‬‬
‫‪ArabicConsole.WriteLine‬‬
‫98 ‪Case 80 To‬‬
‫‪ArabicConsole.WriteLine‬‬
‫09 => ‪Case Is‬‬
‫‪ArabicConsole.WriteLine‬‬
‫‪End Select‬‬
‫66‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺍﻟﻤﺯﻴﺩ ﺍﻴﻀﺎ، ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻔﺎﺼﻠﺔ ﺒﻤﺭﻭﻨﺔ ﻜﺎﻤﻠﺔ، ﻭﺒﻨﻔﺱ ﺍﻟﻤﻨﻁﻕ ﺍﻟﺴﺎﺒﻕ:‬
‫‪Dim Letter As Char‬‬
‫…‬
‫…‬
‫‪Select Case Letter‬‬
‫‪Case "A"c To "Z"c, "a"c To "z"c‬‬
‫)"ﺣﺮف ا ﲜﺪ ي"( ‪ArabicConsole.WriteLine‬‬
‫‪Case "0"c To "9"c‬‬
‫)"ﻋﺪ د"( ‪ArabicConsole.WriteLine‬‬
‫‪Case "."c, ":"c, " "c, ";"c, "?"c‬‬
‫)"رﻣ ﺰ"( ‪ArabicConsole.WriteLine‬‬
‫‪Case Else‬‬
‫)"ﻏﲑ ﻣﻌ ﺮو ف"( ‪ArabicConsole.WriteLine‬‬
‫‪End Select‬‬

‫ﺍﻟﻔﺎﺼﻠﺔ ﺍﻟﺘﻲ ﺍﺴﺘﺨﺩﻤﻨﺎﻫﺎ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﺘﻤﺜل ﺍﺩﺍﺓ ﺍﻟﺭﺒﻁ ‪ Or‬ﺍﻟﻤﻨﻁﻘﻴﺔ:‬
‫‪Select Case True‬‬
‫0 < ‪Case x > 0, Y‬‬
‫ﺗﻌﺎد ل '‬
‫)0 < ‪' If (X > 0) Or (Y‬‬
‫…‬
‫‪End Select‬‬
‫‪Select Case False‬‬
‫0 < ‪Case x > 0, Y‬‬
‫ﺗﻌﺎد ل '‬
‫) )0 < ‪' If ( Not (X > 0) ) Or ( Not (Y‬‬
‫…‬
‫‪End Select‬‬

‫اﻟﺤﻠﻘﺎت اﻟﺘﻜﺮارﻳ ﺔ‬
‫ﺤﺩﺩ ﺍﻟﻘﻴﻤﺔ ﺍﻻﺒﺘﺩﺍﺌﻴﺔ ﻭﺍﻟﻨﻬﺎﺌﻴﺔ ﻟﺤﻠﻘﺔ ‪:For … Next‬‬
‫‪Dim counter As Integer‬‬
‫4 ‪For counter = 2 To‬‬
‫ﺛﻼث ﻣ ﺮا ت ' )‪ArabicConsole.WriteLine(counter‬‬
‫‪Next‬‬

‫ﺘﺴﺘﻁﻴﻊ ﺍﻟﺘﺤﻜﻡ ﻓﻲ ﻤﻘﺩﺍﺭ ﺍﻟﺯﻴﺎﺩﺓ ﺍﻭﺍﻟﻨﻘﺼﺎﻥ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪:Step‬‬
‫1- ‪For counter = 5 To 1 Step‬‬
‫…‬

‫‪Next‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫76‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻀﻊ ﻓﻲ ﺍﻋﺘﺒﺎﺭﻙ ﺍﻥ ﻤﺘﻐﻴﺭ ﺍﻟﺤﻠﻘﺔ ﺴﻴﺯﻴﺩ ﺍﻭ ﻴﻨﻘﺹ ﺒﺎﻟﻤﻘﺩﺍﺭ ﺍﻟﻤﺤﺩﺩ ﺤﺘﻰ ﺒﻌﺩ ﻨﻬﺎﻴﺔ ﺍﻟﺤﻠﻘﺔ:‬
‫1- ‪For counter = 5 To 1 Step‬‬
‫…‬
‫‪Next‬‬
‫ﻗﻴﻤﺔ اﻟﻌ ﺪاد 0 وﻟﻴﺲ 1 '‬
‫0 ' )‪ArabicConsole.WriteLine(counter‬‬

‫ﺍﻟﻤﺯﺍﺡ ﻤﻊ ﻤﺘﻐﻴﺭ ﺍﻟﺤﻠﻘﺔ ﺩﺍﺨل ﺍﻟﺤﻠﻘﺔ ﻓﻴﻪ ﺸﺊ ﻤﻥ ﺍﻟﺨﻁﺭ، ﻓﻌﺩﺩ ﻤﺭﺍﺕ ﺍﻟﺘﻜﺭﺍﺭ ﻟﻠﺤﻠﻘﺔ ﺍﻟﺘﺎﻟﻴـﺔ ﻫـﻭ‬

‫ﻭﺍﺤﺩ ﻓﻘﻁ:‬

‫001 ‪For counter = 1 To‬‬
‫001 = ‪counter‬‬
‫…‬
‫‪Next‬‬

‫ﻭﻗﺒل ﺍﻨﺘﻬﺎﺀ ﺍﻟﻤﺩﺓ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ﻟﻠﺤﻠﻘﺔ، ﻴﻤﻜﻨﻙ ﻗﻁﻌﻬﺎ ﻭﺍﻨﻬﺎﺌﻬﺎ ﺒﻌﺒﺎﺭﺓ ‪:Exit For‬‬
‫05 ‪For counter = 1 To‬‬
‫…‬
‫‪If y = 10 Then‬‬
‫‪Exit For‬‬
‫‪End If‬‬
‫…‬
‫‪Next‬‬

‫ﺤﻠﻘﺔ ﺍﺨﺭﻯ ﺠﻤﻴﻠﺔ ﺠﺩﺍ ﺘﻌﺭﻑ ﺒـ ‪ For Each‬ﺘﻁﺒﻕ ﻋﻠﻰ ﺍﻟﻤﺼـﻔﻭﻓﺎﺕ ‪ Arrays‬ﺍﻭ ﺍﻟﻤﺠﻤﻭﻋـﺎﺕ‬
‫‪:Collections‬‬
‫‪Dim x(5) As Integer‬‬
‫‪Dim y As Integer‬‬
‫…‬
‫…‬
‫‪For Each y In x‬‬
‫)‪ArabicConsole.WriteLine(y‬‬
‫‪Next‬‬

‫ﻣﻼﺣﻈﺔ‬
‫ا ن آﻨﺖ ﻣﺒﺘﺪءً، ﻓﻼ ﺗﺴﺘﺨﺪم اﻟﺤﻠﻘﺔ ‪ For Each‬آﺜﻴـﺮا هـﺬﻩ اﻻﻳـﺎم ﺣﺘـﻰ‬
‫ا‬
‫ً‬
‫ﺗ ﺼﻞ اﻟﻰ اﻟﻔ ﺼﻞ اﻟﺨﺎﻣﺲ اﻟﻮاﺟﻬـﺎت، اﻟﺘﻔـﻮﻳﺾ، واﻟﻤﻮاﺻـﻔﺎت ، ﺣﻴـﺚ‬
‫ﺳﺘﺠﺪ اﻟﻤﺰﻳﺪ ﻣﻦ اﻟﺘﻔﺎ ﺻﻴﻞ ﻋﻦ اﺳﺘﺨﺪام هﺬﻩ اﻟﺤﻠﻘﺔ.‬
‫86‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻭﻋﻨﺩ ﺍﻟﺤﺩﻴﺙ ﻋﻥ ﺍﻟﺤﻠﻘﺎﺕ ﺍﻟﻼﻨﻬﺎﺌﻴﺔ، ﻓﻠﻥ ﺘﺠﺩ ﺍﻓﻀل ﻤﻥ ﺤﻠﻘﺔ ‪ Do … Loop‬ﺍﻟﻤﺭﻨﺔ ﺠـﺩﺍ، ﺤﻴـﺙ‬
‫ﺘﻤﻜﻨﻙ ﻤﻥ ﻭﻀﻊ ﺍﻟﺸﺭﻁ ﺍﻤﺎ ﻓﻲ ﺍﻋﻠﻰ ﺍﻟﺤﻠﻘﺔ ﺍﻭ ﻓﻲ ﺍﺴﻔﻠﻬﺎ )ﻟﻴﺘﻡ ﺘﻨﻔﻴﺫ ﺍﻭﺍﻤﺭ ﺍﻟﺤﻠ ﻘﺔ ﻤﺭﺓ ﻭﺍﺤﺩﺓ ﻋﻠﻰ ﺍﻻﻗـل‬
‫ﻓﻲ ﺤﺎﻟﺔ ﻭﻀﻊ ﺍﻟﺸﺭﻁ ﺍﺴﻔل ﺍﻟﺤﻠﻘﺔ(. ﺍﻥ ﺍﺴﺘﺨﺩﻤﺕ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ ،Until‬ﺴﻴﺘﻡ ﺘﻜـﺭﺍﺭ ﺍﻟﺤﻠﻘـﺔ ﺤﺘـﻰ‬

‫ﻴﺼﺒﺢ ﺍﻟﺸﺭﻁ ‪ ،True‬ﺍﻤﺎ ﺍﻥ ﻜﺎﻨﺕ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ While‬ﻫﻲ ﺍﻟﻤﺭﺍﻓﻘﺔ، ﻓﺴﻴﺘﻡ ﺘﻜﺭﺍﺭ ﺍﻟﺤﻠﻘﺔ ﻤﺎ ﺩﺍﻤـﺕ‬
‫ﻗﻴﻤﺔ ﺍﻟﺸﺭﻁ ‪:True‬‬
‫‪", MsgBoxStyle.YesNo) = MsgBoxResult.Yes‬ا‪‬ﻲ اﳊﻠﻘ ﺔ ؟"(‪Do Until MsgBox‬‬
‫…‬
‫‪Loop‬‬
‫‪", MsgBoxStyle.YesNo) = MsgBoxResult.No‬ا‪‬ﻲ اﳊﻠﻘ ﺔ ؟"(‪Do While MsgBox‬‬
‫…‬
‫‪Loop‬‬

‫ﺍﺨﻴﺭﺍ، ﺘﺴﺘﻁﻴﻊ ﻓﻲ ﺍﻱ ﻟﺤﻅﺔ ﺍﻟﺨﺭﻭﺝ ﻤﻥ ﺍﻟﺤﻠﻘﺔ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻌﺒﺎﺭﺓ ‪.Exit Do‬‬
‫ﺍﻟﺘﺒﺩﻴل ﺒﻴﻥ ‪ For … Next‬ﻭ ‪:Do … Loop‬‬
‫ﺘﺴﺘﻁﻴﻊ ﺘﺤﻭﻴل ﺤﻠﻘﺔ ‪ For … Next‬ﺍﻟﻰ ﺤﻠﻘﺔ ‪ Do … Loop‬ﻭﺍﻟﻌﻜﺱ ﺼﺤﻴﺢ، ﻟﻜﻥ ﻋﻠﻴﻙ ﺍﻻﻨﺘﺒـﺎﻩ ﺍﻟـﻰ‬
‫ﺍﻥ ﺍﻟﻘﻴﻡ ﺍﻟﺘﻲ ﺘﺤﺩﺩﻫﺎ ﻓﻲ ﺒﺩﺍﻴﺔ ﺍﻟﺤﻠﻘﺔ ‪ For … Next‬ﺘﻤﺜل ﻋﺩﺩ ﺍﻟﺘﻜﺭﺍﺭ ﺤﺘﻰ ﻭﺍﻥ ﺘﻐﻴﺭﺕ ﺩﺍﺨـل ﺍﻟﺤﻠﻘـﺔ،‬
‫ﻓﺒﺎﻟﺭﻏﻡ ﻤﻥ ﺍﻥ ﺍﻟﺤﻠﻘﺘﻴﻥ ﺍﻟﺘﺎﻟﻴﺘﻴﻥ ﻤﺘﺸﺎﺒﻬﺘﻴﻥ:‬
‫5 = ‪A‬‬
‫ﺣﻠﻘ ﺔ ‪' For … Next‬‬
‫‪For counter = 1 To A‬‬
‫…‬
‫‪Next‬‬
‫ﲢﻮﻳﻠﻬﺎ ا ﱃ ‪' Do … Loop‬‬
‫1 = ‪counter‬‬
‫‪Do‬‬
‫…‬
‫1 + ‪counter = counter‬‬
‫‪Loop Until counter > A‬‬

‫ﺍﻻ ﺍﻥ ﺍﻻﺨﺘﻼﻑ ﺴﻴﻅﻬﺭ ﻓﻲ ﺤﺎل ﻤﺎ ﺍﺫﺍ ﺘﻡ ﺘﻐﻴﻴﺭ ﻗﻴﻤﺔ ﺍﻟﻤﺘﻐﻴﺭ ‪ ،A‬ﻓﺎﻟﺤﻠﻘﺔ ﺍﻻﻭﻟـﻰ ‪ For … Next‬ﺴـﻴﺘﻡ‬
‫ﺘﻨﻔﻴﺫﻫﺎ ﺩﺍﺌﻤﺎ ﺨﻤﺱ ﻤﺭﺍﺕ ﺤﺘﻰ ﻭﺍﻥ ﺘﻐﻴﺭﺕ ﻗﻴﻤﺔ ﺍﻟﻤﺘﻐﻴﺭ ‪ A‬ﻓﻲ ﺩﺍﺨل ﺍﻟﺤﻠﻘﺔ، ﺒﻴﻨﻤﺎ ﺘﻐﻴﻴـﺭ ﻗﻴﻤـﺔ ﺍﻟﻤﺘﻐﻴـﺭ‬

‫ﻴﺅﺜﺭ ﺒﺸﻜل ﻜﺒﻴﺭ ﻋﻠﻰ ﻋﺩﺩ ﻤﺭﺍﺕ ﺘﻜﺭﺍﺭ ﺍﻟﺤﻠﻘﺔ ﺍﻻﺨﺭﻯ ‪.Do … Loop‬‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫96‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻣﺠﺎﻻت اﻻﺳﻤﺎء ‪Namespaces‬‬
‫ﺍﻟﻔﻜﺭﺓ ﻤﻥ ﻤﺠﺎﻻﺕ ﺍﻻﺴﻤﺎﺀ ‪ Namespaces‬ﺘﻘﺘﻀـﻲ ﺘﻭﺯﻴـﻊ ﺍﻻﺴـﻤﺎﺀ ﺍﻟﻤﺘﺸـﺎﺒﻬﺔ ﻟﻤﻌﺭﻓـﺎﺕ ﺍﻟﺒﺭﻨـﺎﻤﺞ‬

‫)ﻜﺎﺴﻤﺎﺀ ﺍﻟﻔﺌﺎﺕ ‪ ،Classes‬ﺍﻟﻭﺤﺩﺍﺕ ﺍﻟﺒﺭﻤﺠﻴﺔ ‪ ،Modules‬ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ‪ ... Structures‬ﺍﻟـﺦ( ﺍﻟـﻰ ﻜﺘـل‬
‫ﻤﺨﺘﻠﻔﺔ ﺘﺴﻤﻰ ﻤﺠﺎل ﺍﻻﺴﻤﺎﺀ ‪ ،Namespace‬ﺒﺤﻴﺙ ﺘﺴـﻬل ﻋﻠﻴـﻙ ﺘﺭﺘﻴـﺏ ﺍﺴـﻤﺎﺌﻬﺎ ﻋﻠـﻰ ﻤﺠﻤﻭﻋـﺎﺕ،‬

‫ﻭﺘﻤﻜﻨﻙ ﺍﻴﻀﺎ ﻤﻥ ﺘﻌﺭﻴﻑ ﺍﺴﻤﺎﺀ ﻤﺘﺸﺎﺒﻬﻪ ﻟﻤﻌﺭﻓﺎﺕ ﻤﺨﺘﻠﻔﺔ. ﻓﻠﻭ ﻋﺭﻓﻨﺎ ﺘﺭﻜﻴﺏ ﻟﻠﻔﺄﺭ ﺒﺎﺴﻡ ‪:Mouse‬‬

‫‪Structure Mouse‬‬
‫…‬
‫…‬
‫‪End Structure‬‬

‫ﻓﻼ ﻴﻤﻜﻨﻨﺎ ﺍﺴﺘﺨﺩﺍﻡ ﻨﻔﺱ ﺍﻻﺴﻡ ﻟﺘﻌﺭﻴﻑ ﺘﺭﻜﻴﺏ ﺍﺨﺭ -ﻴﻤﺜل ﺠﻬﺎﺯ ﺍﻟﻔـﺄﺭﺓ - ﺒـﻨﻔﺱ ﺍﻻﺴـﻡ ‪ .Mouse‬ﻟـﺫﻟﻙ‬
‫ﺴﻨﻘﻭﻡ ﺒﺘﻌﺭﻴﻑ ﻤﺠﺎﻻﺕ ﺍﺴﻤﺎﺀ ﻤﺨﺘﻠﻔﺔ.‬

‫ﺗﻌﺮﻳﻒ ﻣﺠﺎل اﺳﻤﺎء‬

‫ﻗﺒل ﺍﻥ ﺘﺒﺩﺃ ﺒﺘﻌﺭﻴﻑ ﻤﺠﺎﻻﺕ ﺍﺴﻤﺎﺀ ﺨﺎﺼﺔ ﺒـﻙ، ﻋﻠﻴـﻙ ﻤﻌﺭﻓـﺔ ﺍﻥ ﺍﻟﻤﺸـﺭﻭﻉ ‪ Project‬ﺍﻟﺤـﺎﻟﻲ ﺍﻟـﺫﻱ‬

‫ﺘﺼﻤﻤﻪ ﻗﺩ ﻋﺭﻑ ﻤﺠﺎل ﺍﺴﻡ ﺠﺩﻴﺩ، ﻭﻴﻜﻭﻥ ﺍﺴﻤﻪ -ﺒﺸﻜل ﻤﺒﺩﺌﻲ - ﻨﻔـﺱ ﺍﺴـﻡ ﺍﻟﻤﺸـﺭﻭﻉ. ﻴﻤﻜﻨـﻙ ﺘﻐﻴﻴـﺭ‬
‫ﻤﺠﺎل ﺍﻻﺴﻡ ﻤﻥ ﻨﺎﻓﺫﺓ ‪ ،Project Property Pages‬ﻭﻤﻥ ﺜﻡ ﻜﺘﺎﺒﺔ ﺍﺴﻡ ﻤﺠﺎل ﺍﻻﺴﻤﺎﺀ ﻓـﻲ ﺨﺎﻨـﺔ ‪Root‬‬

‫‪) namespace‬ﺸﻜل 2 -5(.‬

‫ﺸﻜل 2 -5: ﺘﺴﻴﻤﺔ ﻤﺠﺎل ﺍﻻﺴﻤﺎﺀ ﺍﻟﺠﺫﺭﻱ ﻟﻠﻤﺸﺭﻭﻉ.‬
‫07‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻫﺫﺍ ﺍﻻﺴﻡ ﺍﻟﺫﻱ ﺍﺨﺘﺭﺘﻪ ﻴﻤﺜل ﻤﺠﺎل ﺍﻻﺴﻤﺎﺀ ﺍﻟﺠﺫﺭﻱ ﻭﺍﻟﺭﺌﻴﺴـﻲ ﻟﻠﻤﺸـﺭﻭﻉ ﺍﻟﺤـﺎﻟﻲ، ﻭﺠﻤﻴـﻊ ﺍﻟﻤﻌﺭﻓـﺎﺕ‬
‫ﻭﻤﺠﺎﻻﺕ ﺍﻻﺴﻤﺎﺀ ﺍﻻﺨﺭﻯ ﺘﺎﺒﻌﺔ ﺍﻭ ﺩﺍﺨﻠﺔ -ﺍﻥ ﺼﺢ ﺍﻟﺘﻌﺒﻴﺭ - ﻀﻤﻥ ﺤﻴﺯ ﻫﺫﺍ ﺍﻟﻤﺠﺎل.‬

‫ﺒﺭﻤﺠﻴﺎ، ﻴﻤﻜﻥ ﺘﻌﺭﻴﻑ ﺍﻟﻤﺯﻴﺩ ﻤﻥ ﻤﺠﺎﻻﺕ ﺍﻻﺴﻤﺎﺀ ﻓﻲ ﺩﺍﺨل ﻤﺸﺭﻭﻋﻙ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤـﺔ ﺍﻟﻤﺤﺠـﻭﺯﺓ‬

‫‪ Namespace‬ﻭﺘﺫﻴﻴل ﺍﻟﻤﺠﺎل ﺒﺎﻟﻌﺒﺎﺭﺓ ‪:End Namespace‬‬
‫‪Namespace Devices‬‬
‫…‬
‫…‬
‫‪End Namespace‬‬

‫ﻴﻤﻜﻨﻙ ﺍﻟﺒﺩﺀ ﺒﺎﻀﺎﻓﺔ ﻜل ﺍﻟﻤﻌﺭﻓﺎﺕ ﺍﻟﺘﻲ ﺘﺭﻏﺏ ﺒﺤﻀﻨﻬﺎ ﺩﺍﺨـل ﻫـﺫﺍ ﺍﻟﻤﺠـﺎل، ﻭﺍﻟﻤﻌﺭﻓـﺎﺕ ﺍﻟﺘـﻲ‬
‫ﻴﻤﻜﻨﻙ ﺘﻌﺭﻴﻔﻬﺎ ﻓﻲ ﺩﺍﺨل ﻤﺠﺎل ﺍﻻﺴـﻤﺎﺀ ﻫـﻲ ﺍﻤـﺎ ﺃﻥ ﺘﻜـﻭﻥ ﻓﺌـﺎﺕ ‪ ،Classes‬ﺍﻭ ﻭﺤـﺩﺍﺕ ﺒﺭﻤﺠـﺔ‬
‫‪ ،Modules‬ﺍﻭ ﺘﺭﻜﻴﺒﺎﺕ ‪ ،Structures‬ﺍﻭ ﻭﺍﺠﻬﺎﺕ ‪ Interfaces‬ﺍﻭ ﺘﺭﻜﻴﺒﺎﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Enum‬ﻓﻘﻁ:‬
‫‪Namespace Devices‬‬
‫‪Structure Mouse‬‬
‫…‬
‫…‬
‫‪End Structure‬‬
‫‪Structure Printer‬‬
‫…‬
‫…‬
‫‪End Structure‬‬

‫…‬
‫…‬
‫‪End Namespace‬‬

‫‪Namespace Animals‬‬
‫‪Structure Mouse‬‬
‫…‬
‫…‬
‫‪End Structure‬‬
‫‪Structure Cat‬‬
‫…‬
‫…‬
‫‪End Structure‬‬

‫…‬
‫…‬
‫‪End Namespace‬‬

‫اﻧﻈﺮ اﻳﻀﺎ‬
‫ﺳﻴﺘﻢ اﻟﺤﺪﻳﺚ ﻋﻦ اﻟﻔﺌﺎت ‪ Classes‬ﻓﻲ اﻟﻔ ﺼﻞ اﻟﺜﺎﻟﺚ اﻟﻔﺌﺎت واﻟﻜﺎﺋﻨـﺎت ،‬
‫واﻟﻮاﺟﻬــﺎت ‪ Interfaces‬ﻓــﻲ اﻟﻔ ﺼــﻞ اﻟﺨــﺎﻣﺲ اﻟﻮاﺟﻬــﺎت ، اﻟﺘﻔــﻮﻳﺾ،‬
‫واﻟﻤﻮاﺻﻔﺎت. اﻣﺎ اﻟﻮﺣـﺪات اﻟﺒﺮﻣﺠﻴـﺔ ‪ Modules‬واﻟﺘﺮآﻴﺒـﺎت -ﺳـﻮاء آﺎﻧـﺖ‬
‫‪ Enums‬او ‪ Structures‬ﻓﻘﺪ ﻓ ﺼﻠﺘﻬﺎ ﺳﺎﺑﻘﺎ ﻓﻲ هﺬا اﻟﻔ ﺼﻞ.‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫17‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺍﺨﻴﺭﺍ، ﻤﺠﺎﻻﺕ ﺍﻻﺴﻤﺎﺀ ﻤﻤﻜﻥ ﺍﻥ ﺘﻜﻭﻥ ﻤﺘﺩﺍﺨﻠﺔ ‪:Nested‬‬
‫‪Namespace Devices‬‬
‫‪Namespace Inputs‬‬
‫‪Structure Mouse‬‬
‫…‬
‫…‬
‫‪End Structure‬‬
‫‪Structure Keyboard‬‬
‫…‬
‫…‬
‫‪End Structure‬‬
‫…‬
‫…‬
‫‪End Namespace‬‬
‫‪Namespace Outputs‬‬
‫‪Structure Monitor‬‬
‫…‬
‫…‬
‫‪End Structure‬‬
‫‪Structure Printer‬‬
‫…‬
‫…‬
‫‪End Structure‬‬
‫…‬
‫…‬
‫‪End Namespace‬‬

‫…‬
‫…‬
‫‪End Namespace‬‬

‫اﻟﻮﺻﻮل اﻟﻰ ﻋﻨﺎﺻﺮ ﻣﺠﺎل اﻻﺳﻤﺎء‬
‫ﻜل ﻤﺎ ﻫﻭ ﻤﻁﻠﻭﺏ ﻤﻨﻙ ﺘﺤﺩﻴﺩ ﺍﺴﻡ ﻤﺠﺎل ﺍﻻﺴﻤﺎﺀ ﻭﻤﻥ ﺜﻡ ﺫﻜﺭ ﺍﻟﻤﻌﺭﻑ ﺍﻟﺫﻱ ﺘﺭﻏﺏ ﻓﻲ ﺍﺴﺘﺨﺩﺍﻤﻪ:‬
‫‪Dim X As Animals.Mouse‬‬
‫‪Dim Y As Devices.Mouse‬‬
‫…‬
‫…‬

‫ﻭﺒﺎﻟﻨﺴﺒﺔ ﻟﻤﺠﺎﻻﺕ ﺍﻻﺴﻤﺎﺀ ﺍﻟﻤﺘﺩﺍﺨﻠﺔ، ﻋﻠﻴﻙ ﺫﻜﺭ ﺠﻤﻴﻊ ﺍﻟﻤﺠﺎﻻﺕ ﺍﻟﺤﺎﻀـﻨﺔ ﻟﻬـﺎ، ﻭﺒـﻨﻔﺱ ﺍﻟﺘﺭﺘﻴـﺏ‬

‫ﺍﻟﻤﻨﻁﻘﻲ ﺍﻟﺫﻱ ﺘﺘﺒﻌﻪ ﻟﻠﻭﺼﻭل ﺇﻟﻰ ﻋﻨﺎﺼﺭ ﺘﺭﻜﻴﺒﺎﺕ ‪ Structures‬ﻤﺘﺩﺍﺨﻠﺔ:‬

‫‪Dim X As Devices.OutPuts.Printer‬‬
‫‪Dim Y As Devices.OutPuts.Screen‬‬
‫‪Dim Z As Devices.Inputs.Keyboard‬‬
‫27‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺍﺴﺘﺨﺩﻡ ﺍﻻﺴﻡ ﺍﻟﻜﺎﻤل ﻟﻤﺠﺎل ﺍﻻﺴﻤﺎﺀ ﺍﻥ ﻜﻨﺕ ﺨﺎﺭﺝ ﺍﻟﻤﺠﺎل ﻓﻘﻁ )ﻜﻤﺎ ﻓﻲ ﺍﻻﻤﺜﻠﺔ ﺍﻟﺴـﺎﺒﻘﺔ(، ﺍﻤـﺎ ﺇﻥ‬
‫ﻜﻨﺕ ﺩﺍﺨل ﺍﻟﻤﺠﺎل ﻓﻼﻴﻭﺠﺩ ﺩﺍﻋﻲ ﻟﺘﺤﺩﻴﺩ ﺍﺴﻡ ﺍﻟﻤﺠﺎل ﺍﻟﺤﺎﻟﻲ:‬
‫داﺧﻞ ﳎﺎل اﻻﲰﺎ ء ‪' Devices.Inputs‬‬
‫‪Dim X As Keyboard‬‬
‫‪Dim Y As Mouse‬‬
‫هﻨﺎ اﺳﺘﺨ ﺪﻣﺖ ﳎ ﺎل ﺧﺎ رﺟﻲ ا ﺧ ﺮ ' ‪Dim Z As OutPuts.Printer‬‬

‫اﺳﺘﻴﺮاد ﻣﺠﺎل اﺳﻤﺎء ﺑﺎﺳﺘﺨﺪام ‪Imports‬‬
‫ﻴﻘﺼﺩ ﺒﺠﻤﻠﺔ ﺍﺴﺘﻴﺭﺍﺩ ﻤﺠﺎل ﺍﺴﻤﺎﺀ ﺍﻱ ﺘﻀﻤﻴﻥ ﻤﺠﺎل ﺍﺴﻤﺎﺀ ﻤﻌﻴﻥ ﻭﺩﻤﺠﻪ ﻓﻲ ﻤﺠﺎل ﺍﻻﺴﻤﺎﺀ ﺍﻟﺤـﺎﻟﻲ ﺒﺤﻴـﺙ‬
‫ﻴﻤﻜﻨﻙ ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﺠﻤﻴﻊ ﻋﻨﺎﺼﺭﻩ ﺩﻭﻥ ﺍﻟﺤﺎﺠﺔ ﻟﻼﻟﺘﺯﺍﻡ ﺒﺎﻟﺼﻴﻐﺔ ﺍﻟﻜﺎﻤﻠﺔ ﻻﺴﻡ ﺍﻟﻤﺠﺎل، ﻓﺎﻟﺸﻴﻔﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ:‬
‫‪Dim X As Devices.OutPuts.Printer‬‬
‫‪Dim Y As Devices.OutPuts.Screen‬‬
‫‪Dim Z As Devices.Inputs.Keyboard‬‬

‫ﻴﻤﻜﻨﻙ ﺍﺨﺘﺼﺎﺭﻩ ﺒﺎﺴﺘﻴﺭﺍﺩ ﺍﻟﻤﺠﺎل ‪ Devices‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪:Imports‬‬
‫‪Imports MyNameSpace.Devices‬‬
‫…‬
‫…‬
‫‪Dim X As OutPuts.Printer‬‬
‫‪Dim Y As OutPuts.Screen‬‬
‫‪Dim Z As Inputs.Keyboard‬‬

‫ﺒل ﺘﺴﺘﻁﻴﻊ ﺍﺨﺘﺼﺎﺭﻩ ﺍﻜﺜﺭ ﻤﻥ ﺫﻟﻙ ﺍﻴﻀﺎ ﺒﺎﺴﺘﻴﺭﺍﺩ ﺍﻟﻤﺠﺎﻻﺕ ﺍﻟﻔﺭﻋﻴﺔ:‬
‫‪Imports MyNameSpace.Devices.OutPuts‬‬
‫‪Imports MyNameSpace.Devices.Inputs‬‬
‫…‬
‫…‬
‫‪Dim X As Printer‬‬
‫‪Dim Y As Screen‬‬
‫‪Dim Z As Keyboard‬‬

‫ﻣﻼﺣﻈﺔ‬
‫ﻋﻨﺪ اﺳﺘﻴﺮاد ﻣﺠﺎل اﺳـﻤﺎء ﺑﺎﺳـﺘﺨﺪام ‪ ، Imports‬ﻻﺑـﺪ ﻣـﻦ آﺘﺎﺑـﺔ اﻻﺳـﻢ‬
‫اﻟﻜﺎﻣﻞ ﻟﻤﺠﺎل اﻻﺳﻤﺎء )ﺑﻤﺎ ﻓﻲ ذﻟﻚ اﺳﻢ ﻣﺠﺎل اﻻﺳﻤﺎء اﻟﺬي ﻳﺤﺘ ﻀﻨﻪ(.‬
‫ﻓﻔﻲ اﻟﺸﻴﻔﺮات اﻟﺴﺎﺑﻘﺔ، اﺳﺘﺨﺪﻣﻨﺎ ﻣﺠـﺎل اﻻﺳـﻤﺎء اﻟﺠـﺬري ﻟﻠﻤﺸـﺮوع‬
‫‪ My NameSpace‬ﻓﻲ آﻞ ﻣﺮة اﺳﺘﻮردﻧﺎ ﻓﻴﻬﺎ ﻣﺠﺎل اﺳﻤﺎء.‬
‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ: ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬
‫37‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﻗﺩ ﺘﻔﺘﺢ ﺸﺭﻜﺔ ﺍﺴﺘﻴﺭﺍﺩ ﻭﺘﺼﺩﻴﺭ ﻓﻲ ﺍﺤﺩ ﺍﻻﻴﺎﻡ، ﻭﺘﺤﺎﻭل ﺍﺴـﺘﻴﺭﺍﺩ ﺠﻤﻴـﻊ ﻤﺠـﺎﻻﺕ ﺍﻻﺴـﻤﺎﺀ ﻓـﻲ‬
‫ﺒﺭﺍﻤﺠﻙ، ﻭﻟﻜﻨﻙ ﺴﺘﺼﺎﺏ ﺒﺨﻴﺒﺔ ﺍﻤل ﻜﺒﻴﺭﺓ ﺍﻥ ﺤﺩﺙ ﺘﻌﺎﺭﻀﺎﺕ، ﻓﻠﻭ ﺤﺎﻭﻟﺕ ﺍﺴﺘﻴﺭﺍﺩ ﻫﺫﻴﻥ ﺍﻟﻤﺠﺎﻟﻴﻥ:‬
‫‪Imports MyNameSpace.Animals‬‬
‫‪Imports MyNameSpace.Devices.Inputs‬‬
‫‪Dim X As Mouse‬‬

‫ﺴﻴﻅﻬﺭ ﻟﻙ ﺍﻟﻤﺘﺭﺠﻡ ﺭﺴﺎﻟﺔ ﺨﻁﺄ ﺒﺴﺒﺏ ﺘﻌﺎﺭﺽ ﺍﺴﻡ ﺍﻟﺘﺭﻜﻴﺏ ‪ Mouse‬ﻓﻲ ﻜﻼ ﺍﻟﻤﺠـﺎﻟﻴﻥ. ﻭﺍﻥ ﻜـﺎﻥ ﻫـﺫﺍ‬
‫ﺴﻴﺴﺒﺏ ﺨﺴﺎﺭﺓ ﻟﺸﺭﻜﺔ ﺍﻻﺴﺘﻴﺭﺍﺩ ﻭﺍﻟﺘﺼﺩﻴﺭ ﺍﻟﺨﺎﺼﺔ ﺒﻙ، ﻓﻴﻤﻜﻨﻙ ﺍﻻﻟﺘﻔﺎﻑ ﺤﻭل ﻫـﺫﺍ ﺍﻟﺘﻌـﺎﺭﺽ ﺒﺘﻌﺭﻴـﻑ‬
‫ﻤﺠﺎل ﺍﺴﻤﺎﺀ ﻤﺅﻗﺕ:‬

‫‪Imports MyNameSpace.Animals‬‬
‫‪Imports tmp = MyNameSpace.Devices.Inputs‬‬
‫‪Dim X As Mouse‬‬
‫‪Dim Y As tmp.Mouse‬‬

‫ﺍﺨﻴﺭﺍ، ﺍﻥ ﺍﺭﺩﺕ ﺍﺴﺘﻴﺭﺍﺩ ﻤﺠﺎﻻﺕ ﺍﺴـﻤﺎﺀ ﻟﻤﺸـﺎﺭﻴﻊ ﻭﺒـﺭﺍﻤﺞ ﺍﺨـﺭﻯ )ﻜﻤﻜﺘﺒـﺔ ﻓﺌـﺎﺕ‬

‫‪.NET‬‬

‫‪ (Framework‬ﻋﻠﻴﻙ ﺍﻀﺎﻓﺔ ﻤﺭﺠﻊ ﻟﻬﺫﻩ ﺍﻟﻤﺠﺎﻻﺕ ﻓﻲ ﺨﺎﻨﺔ ﺍﻟﻤﺭﺍﺠﻊ ﻤـﻥ ﻨﺎﻓـﺫﺓ ﻤﺴﺘﻜﺸـﻑ ﺍﻟﻤﺸـﺭﻭﻉ‬
‫‪) Solution Explorer‬ﺸﻜل 2 -6(.‬

‫ﺸﻜل 2 -6: ﺍﺩﺭﺍﺝ ﻤﺭﺍﺠﻊ ﺍﻀﺎﻓﻴﺔ ﻟﻤﺠﺎﻻﺕ ﺍﺴﻤﺎﺀ ﺍﺨﺭﻯ ﻓﻲ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ.‬

‫اﺳﺘﻴﺮاد ﻣﺠﺎل اﺳﻤﺎء دون اﺳﺘﺨﺪام ‪Imports‬‬

‫ﻁﺭﻴﻘﺔ ﻏﻴﺭ ﺒﺭﻤﺠﻴﺔ ﺍﺨﺭﻯ ﺘﻤﻜﻨﻙ ﻤـﻥ ﺍﺴـﺘﻴﺭﺍﺩ ﻤﺠـﺎﻻﺕ ﺍﺴـﻤﺎﺀ )ﺍﻱ ﺩﻭﻥ ﺍﻟﺤﺎﺠـﺔ ﻻﺴـﺘﺨﺩﺍﻡ ﻋﺒـﺎﺭﺓ‬

‫‪ (Imports‬ﻭﺫﻟﻙ ﺒﺎﻀﺎﻓﺔ ﺠﻤﻴﻊ ﻤﺠﺎﻻﺕ ﺍﻻﺴﻤﺎﺀ ﺍﻟﺘﻲ ﺘﻭﺩ ﺍﺴﺘﻴﺭﺍﺩﻫﺎ ﻓـﻲ ﺒﺭﻨﺎﻤﺠـﻙ ﻋـﻥ ﻁﺭﻴـﻕ ﺨﺎﻨـﺔ‬

‫ﺍﻟﺘﺒﻭﻴﺏ ‪ Imports‬ﻓـﻲ ﺼـﻨﺩﻭﻕ ﺍﻟﺤـﻭﺍﺭ ‪) Project Property Pages‬ﺸـﻜل 2 -7 ﻓـﻲ ﺍﻟﺼـﻔﺤﺔ‬
‫ﺍﻟﻤﻘﺎﺒﻠﺔ(.‬
‫47‬
‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴ ﺎت‬
‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬

‫ﺸﻜل 2 -7: ﺍﺴﺘﻴﺭﺍﺩ ﻤﺠﺎل ﺍﺴﻤﺎﺀ ﺩﻭﻥ ﺍﺴﺘﺨﺩﺍﻡ ‪.Imports‬‬

‫ﻜﺎﻥ ﻫﺫﺍ ﺍﻟﻔﺼل ﻨﻬﺎﻴﺔ ﺍﻟﺒﺩﺍﻴﺔ ﻻﺘﻘﺎﻥ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠـﺔ ‪ .Visual Basic .NET‬ﺘﺒﻘـﻰ ﻟﻨـﺎ ﻤﺠﻤﻭﻋـﺔ ﻤـﻥ‬

‫ـﻔﺎﺕ ‪،Attributes‬‬
‫ـﺎﺕ ‪ ،Interfaces‬ﺍﻟﻤﻭﺍﺼـ‬
‫ـﺔ ‪ ،Inheritance‬ﺍﻟﻭﺍﺠﻬـ‬
‫ـﺭﻯ ﻜﺎﻟﻭﺭﺍﺜـ‬
‫ـﻴﻊ ﺍﻻﺨـ‬
‫ﺍﻟﻤﻭﺍﻀـ‬
‫ﻭﺍﻟﺘﻔﻭﻴﺽ ‪ Delegates‬ﻟﻨﻜﻤل ﻤﺭﺤﻠﺔ ﺘﻌﻠﻡ ﺍﻻﺴﺎﺴﻴﺔ. ﻭﻟﻜﻥ ﻗﺒل ﺫﻟﻙ، ﻤـﻥ ﺍﻟﻤﻬـﻡ ﺠـﺩﺍ ﺍﺴـﺘﻴﻌﺎﺏ ﻓﻜـﺭﺓ‬
‫ﺍﻟﻔﺌﺎﺕ ﻭﺍﻟﻜﺎﺌﻨﺎﺕ ﻋﻨﻭﺍﻥ ﺍﻟﻔﺼل ﺍﻟﺘﺎﻟﻲ.‬

برمجة اطار عمل .NET باستخدام Visual Basic .NET

  • 1.
    ‫ﺑﺮﻣﺠﺔ اﻃﺎر ﻋﻤﻞ‪ .NET‬ﺑﺎﺳﺘﺨﺪام‬ ‫‪Visual Basic .NET‬‬ ‫-- ﺗﺮآﻲ اﻟﻌﺴﻴﺮي‬ ‫ﻨﺴﺨﺔ ﻋﺭﺽ ﻤﻥ ﺍﻟﻤﺭﺍﺠﻌﺔ ﻗﺒل ﺍﻻﺨﻴﺭﺓ ﻤﻥ ﺍﻟﻁﺒﻌﺔ ﺍﻻﻭﻟﻰ ﻟﻠﻜﺘﺎﺏ.‬ ‫ﻤﻼﺤﻅﺔ: ﺍﻻﺨﻁﺎﺀ ﻏﻴﺭ ﻤﻨﻘﺤﺔ .‬
  • 2.
    ‫ﺑﺴﻢ اﷲ اﻟﺮﺣﻤﻦاﻟﺮﺣﻴﻢ‬ ‫)) ﺳﺒ َﺎ َ َ َﺎ ِﻠ َ َ َﺎ ِ ﱠﺎ َﺎ‬ ‫ُ ْﺤ ﻧﻚ ﻟ ﻋ ْﻢ ﻟﻨ إﻟ ﻣ‬ ‫َ ﱠﻤ َ َﺎ ِ ﱠ َ َﻧ َ اﻟ َ ِﻴﻢ اﻟ َ ِﻴﻢ‬ ‫ﻋﻠ ْﺘﻨ إﻧﻚ أ ْﺖ ْﻌﻠ ُ ْﺤﻜ ُ‬ ‫((‬
  • 3.
    ‫اهﺪاء‬ ‫اﻟﺠﻤﺎل ﻓﻲ اﻟﺤﻴﺎةﺷﺊ ﻳﺠﺒﺮ اﻟﻔﺆاد‬ ‫ﻋﻠﻰ ذآﺮﻩ ﻓﻲ آﻞ ﻟﺤﻈﺔ ﻣﻦ ﻟﺤﻈﺎت ﺧﻔﻘﺎﻧﻪ ...‬ ‫وان ﻟﻢ ﺗﻜﻮﻧﻲ ﻣﻦ اﻟﺠﻤﺎل ﻓﻲ اﻟﺤﻴﺎة،‬ ‫ﻓﺤﺴﺒﻲ ان اﻟﺠﻤﺎل ﻗﺪ ﻧﺒﺾ اﻟﻰ اﻟﺤﻴﺎة ﻣﻨﻚ ...‬ ‫اﻣﻲ اﻟﺤﺒﻴﺒﺔ،‬ ‫اهﺪﻳﻚ هﺬا اﻟﻜﺘﺎب ...‬ ‫اﺑﻨﻚ اﻟﻤﺨﻠﺺ‬
  • 4.
    ‫ﺑﺮﻣﺠﺔ اﻃﺎر ﻋﻤﻞ‪.NET‬‬ ‫ﺑﺎﺳﺘﺨﺪام ‪Visual Basic .NET‬‬ ‫اﻟﻄﺒﻌﺔ اﻻوﻟﻰ 3002‬ ‫‪S‬‬ ‫ﺤﻘﻭﻕ ﻜﺘﺎﺏ ﺒﺭﻤﺠﺔ ﺍﻁـﺎﺭ ﻋﻤـل ‪ .NET‬ﺒﺎﺴـﺘﺨﺩﺍﻡ ‪ Visual Basic .NET‬ﻤﺤﻔﻭﻅـﺔ‬ ‫ﻟﻠﻤﺅﻟﻑ، ﻭﻻ ﻴﺤﻕ ﻷﻱ ﺸﺨﺹ ﺍﻭ ﺠﻬﺔ ﺭﺴﻤﻴﺔ ﻤﻥ ﺍﻋﺎﺩﺓ ﻨﺸﺭ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﺍﻭ ﺠـﺯﺀ ﻤﻨـﻪ ﺒـﺄﻱ‬ ‫ﻭﺴﻴﻠﺔ ﺩﻭﻥ ﺍﻻﺫﻥ ﺍﻟﺨﻁﻲ ﻤﻥ ﺍﻟﻤﺅﻟﻑ.‬ ‫‪S‬‬ ‫ﺍﺴﻤﺎﺀ ﺍﻟﺒﺭﺍﻤﺞ ﺍﻭ ﺍﻟﺘﻘﻨﻴـﺎﺕ ﺍﻭ ﺍﻟﺸـﺭﻜﺎﺕ )ﻜــ ‪،ADO .NET ،Visual Basic .NET‬‬ ‫‪.... Microsoft‬ﺍﻟﺦ( ﻫﻲ ﻋﻼﻤﺎﺕ ﺘﺠﺎﺭﻴﺔ ﻤﺴﺠﻠﺔ ﻻﺼﺤﺎﺒﻬﺎ، ﻭﺍﻟﻤﺅﻟﻑ ﻴﺤﺘﺭﻡ ﻫﺫﻩ ﺍﻟﻌﻼﻤـﺎﺕ‬ ‫ﻭﻴﻘﺭ ﺒﻬﺎ ﻟﻤﺎﻟﻴﻜﻬﺎ ﺴﻭﺍﺀ ﻜﺎﻨﻭﺍ ﺍﻓﺭﺍﺩ ﺍﻭ ﺸﺭﻜﺎﺕ ﺍﻭ ﺍﻱ ﺠﻬﺎﺕ ﺘﻨﻅﻴﻤﻴﺔ ﺍﺨﺭﻯ، ﻭﻟـﻡ ﻴـﺘﻡ ﺫﻜﺭﻫـﺎ‬ ‫ﻟﻼﺨﺘﺼﺎﺭ.‬ ‫‪S‬‬ ‫ﺍﺴﻤﺎﺀ ﺍﻻﺸﺨﺎﺹ ﺍﻭ ﺍﻟﺸﺭﻜﺎﺕ ﻭﺍﻟﻤﺫﻜﻭﺭﺓ ﻓﻲ ﺍﻤﺜﻠﺔ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻫﻲ ﺍﺴﻤﺎﺀ ﻭﻫﻤﻴـﺔ ﻭﻻ ﻴﻘﺼـﺩ‬ ‫ﺒﻬﺎ ﺘﺤﺩﻴﺩ ﻫﻭﻴﺔ ﺍﺸﺨﺎﺹ ﺍﻭ ﺠﻬﺎﺕ ﻤﻌﻴﻨﺔ.‬ ‫‪S‬‬ ‫ﺘﻡ ﺍﺨﺘﺒﺎﺭ ﺍﻟﻤﺎﺩﺓ ﺍﻟﻌﻠﻤﻴﺔ ﻓﻲ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻭﺍﻟﺘﺤﻘـﻕ ﻤﻨﻬـﺎ ﻭﻤﺭﺍﺠﻌﺘﻬـﺎ، ﺍﻻ ﺍﻥ ﺍﻟﻤﺅﻟـﻑ ﻏﻴـﺭ‬ ‫ﻤﺴﺅﻭل ﺒﺎﻱ ﺸﻜل ﻤﻥ ﺍﻻﺸﻜﺎل ﻋﻥ ﺍﻻﻀﺭﺍﺭ ﺍﻟﻨﺎﺘﺠﺔ ﻤﻥ ﺘﻁﺒﻴﻕ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻓﻲ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ.‬ ‫‪S‬‬ ‫ﺠﻤﻴﻊ ﺍﻻﺭﺍﺀ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﺘﻌﺒﺭ ﻋﻥ ﺭﺃﻱ ﺍﻟﻤﺅﻟﻑ ﺍﻟﺸﺨﺼﻲ ﺤﺘـﻰ ﻟـﻭ ﻟـﻡ ﺘﻭﺜـﻕ‬ ‫ﺒﺎﻤﺜﻠﺔ ﺍﻭ ﺍﺩﻟﺔ ﺤﺴﻴﺔ.‬
  • 5.
    ‫اﻟﻤﺤﺘﻮﻳﺎت‬ ‫ﺘﻤﻬﻴﺩ‬ ‫ﺘﻘﺩﻴﻡ‬ ‫ﺍﻟﻤﻘﺩﻤﺔ‬ ‫ﻟﻤﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ؟‬ ‫ﻤﺎﺫﺍﻋﻥ ﻤﺒﺭﻤﺠﻲ 6‪ Visual Basic 1Î‬؟‬ ‫ﺍﻟﻤﺼﻁﻠﺤﺎﺕ ﺘﻌﺭﻴﺏ ﺍﻡ ﺘﻌﺫﻴﺏ؟‬ ‫ﻤﺎﺫﺍ ﻴﻘﺩﻡ ﻟﻙ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ؟‬ ‫ﺍﻟﻘﺭﺹ ﺍﻟﻤﺩﻤﺞ ‪CD-ROM‬‬ ‫ﺼﻔﺤﺔ ﺍﻟﻜﺘﺎﺏ ﻋﻠﻰ ﺍﻻﻨﺘﺭﻨﺕ‬ ‫ﺍﻻﺨﻁﺎﺀ ) ﻫﺎﻡ ﺠﺩﺍ(‬ ‫ﻜﻠﻤﺔ ﺍﺨﻴﺭﺓ‬ ‫اﻟﺠﺰء اﻻول: اﻻﺳﺎﺳﻴﺎت‬ ‫ﺍﻟﻔﺼل ﺍﻻﻭل: ﺘﻌﺭﻑ ﻋﻠﻰ ‪Visual Basic .NET‬‬ ‫ﺍﻟﺤﻴﺎﺓ ﻗﺒل ‪.NET‬‬ ‫ﺍﻟﺒﺭﻤﺠﺔ ﺘﺤﺕ ‪DOS‬‬ ‫ﺍﻻﻨﺘﻘﺎل ﺍﻟﻰ ‪Windows‬‬ ‫ﺍﻟﺤﻠﻡ ﺍﺼﺒﺢ ﺤﻘﻴﻘﺔ ﻤﻊ ‪COM‬‬ ‫ﺘﺤﺩﻴﺎﺕ ﺍﻻﻨﺘﺭﻨﺕ‬ ‫ﻋﺸﺭﺍﺕ ﺍﻟﺘﻘﻨﻴﺎﺕ ﻻﺩﺍﺀ ﺍﻟﻭﻅﺎﺌﻑ‬ ‫ﺍﻟﺤﻴﺎﺓ ﺒﻌﺩ ‪.NET‬‬ ‫ﺍﻻﺴﺘﻘﻼﻟﻴﺔ ﻋﻥ ﻤﻨﺼﺎﺕ ﺍﻟﻌﻤل‬ ‫‪ .NET‬ﻨﺴﺨﺔ ﻤﺤﺴﻨﺔ ﻤﻥ ‪COM‬‬ ‫ﺘﻜﺎﻤل ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ‬ ‫ﺨﺩﻤﺎﺕ ﻭﻴﺏ ﻫﻲ ﻤﺴﺘﻘﺒل ﺍﻻﻨﺘﺭﻨﺕ1‬ ‫ﻤﺎﺫﺍ ﻋﻥ ﺍﻟﻤﺒﺭﻤﺞ ﺍﻟﻌﺭﺒﻲ؟‬ ‫ﻤﺤﺘﻭﻴﺎﺕ ﺍﻁﺎﺭ ﺍﻟﻌﻤل ‪.NET Framework‬‬ ‫ﺍﻟﺘﺭﺠﻤﺔ ﻋﻠﻰ ﺍﻟﻔﻭﺭ ‪JIT‬‬ ‫ﺍﻟﻤﺠﻤﻌﺎﺕ ‪Assemblies‬‬ ‫ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ ‪Visual Studio .NET‬‬ ‫ﻨﻭﺍﻓﺫ ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ‬
  • 6.
    ‫ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﺭﺌﻴﺴﺔ‬ ‫ﺍﺸﺭﻁﺔ ﺍﻻﺩﻭﺍﺕ‬ ‫ﻜﺘﺎﺒﺔﺒﺭﻨﺎﻤﺠﻙ ﺍﻻﻭل‬ ‫ﺍﻟﺤﻠﻭل ﻭﺍﻟﻤﺸﺎﺭﻴﻊ‬ ‫ﺍﻨﻭﺍﻉ ﺍﻟﻤﺸﺎﺭﻴﻊ‬ ‫ﺒﻨﺎﺀ ﺒﺭﻨﺎﻤﺠﻙ ﺍﻻﻭل‬ ‫ﺍﺴﺘﺨﺩﺍﻡ ‪ArabicConsole‬‬ ‫ﺍﻟﺘﺭﺠﻤﺔ ﻭﺍﻟﺘﻭﺯﻴﻊ‬ ‫ﺍﻟﻔﺼل ﺍﻟﺜﺎﻨﻲ: ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ‬ ‫ﺍﻟﻭﺤﺩﺍﺕ ﺍﻟﺒﺭﻤﺠﻴﺔ ‪Modules‬‬ ‫ﺍﻻﺠﺭﺍﺀ ‪Sub Main‬‬ ‫ﺍﻻﺠﺭﺍﺀ ‪Sub New‬‬ ‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻭﺍﻟﺜﻭﺍﺒﺕ‬ ‫ﺍﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ‬ ‫ﻗﺎﺒﻠﻴﺔ ﺍﻟﺭﺅﻴﺔ ﻭﻋﻤﺭ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ‬ ‫ﺍﻨﻭﺍﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ‬ ‫ﺍﻟﺜﻭﺍﺒﺕ‬ ‫ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻭﺍﻟﻤﺼﻔﻭﻓﺎﺕ‬ ‫ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻤﻥ ﻨﻭﻉ ‪Enum‬‬ ‫ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻤﻥ ﻨﻭﻉ ‪Structure‬‬ ‫ﺍﻟﻤﺼﻔﻭﻓﺎﺕ‬ ‫ﺍﻻﺠﺭﺍﺀﺍﺕ ﻭﺍﻟﺩﻭﺍل‬ ‫ﺍﻻﺭﺴﺎل ﺒﺎﻟﻤﺭﺠﻊ ﺍﻭ ﺍﻟﻘﻴﻤﺔ‬ ‫ﺘﺨﺼﻴﺹ ﺍﻟﻭﺴﻴﻁﺎﺕ ﺍﻟﻤﺭﺴﻠﺔ‬ ‫ﺘﺠﺎﻭﺯ ﺍﻟﺤﺩﻭﺩ ﻤﻊ ‪Windows API‬‬ ‫ﺍﻟﺘﻔﺭﻉ ﻭﺍﻟﺘﻜﺭﺍﺭ‬ ‫ﺍﻟﺘﻔﺭﻉ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪If … Then‬‬ ‫ﺍﻟﺘﻔﺭﻉ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪Select Case‬‬ ‫ﺍﻟﺤﻠﻘﺎﺕ ﺍﻟﺘﻜﺭﺍﺭﻴﺔ‬ ‫ﻤﺠﺎﻻﺕ ﺍﻻﺴﻤﺎﺀ‬ ‫ﺘﻌﺭﻴﻑ ﻤﺠﺎل ﺍﺴﻤﺎﺀ‬ ‫ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﻋﻨﺎﺼﺭ ﻤﺠﺎل ﺍﻻﺴﻤﺎﺀ‬ ‫ﺍﺴﺘﻴﺭﺍﺩ ﻤﺠﺎل ﺍﺴﻤﺎﺀ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪Imports‬‬
  • 7.
    ‫ﺍﺴﺘﻴﺭﺍﺩ ﻤﺠﺎل ﺍﺴﻤﺎﺀﺩﻭﻥ ﺍﺴﺘﺨﺩﺍﻡ ‪Imports‬‬ ‫ﺍﻟﻔﺼل ﺍﻟﺜﺎﻟﺙ: ﺍﻟﻔﺌﺎﺕ ﻭﺍﻟﻜﺎﺌﻨﺎﺕ‬ ‫ﻤﺩﺨﻠﻙ ﺍﻟﺴﺭﻴﻊ ﻟﻠﻔﺌﺎﺕ‬ ‫ﺒﻨﺎﺀ ﺍﻋﻀﺎﺀ ﺍﻟﻔﺌﺎﺕ‬ ‫ﺍﻟﺤﻘﻭل ‪Fields‬‬ ‫ﺍﻟﻁﺭﻕ ‪Methods‬‬ ‫ﺍﻟﺨﺼﺎﺌﺹ ‪Properties‬‬ ‫ﺍﻻﺤﺩﺍﺙ ‪Event‬‬ ‫ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﺎﺌﻨﺎﺕ‬ ‫ﻤﺎﻫﻲ ﺤﻘﻴﻘﺔ ﺍﻟﻜﺎﺌﻥ؟‬ ‫ﻋﺒﺎﺭﺍﺕ ﺨﺎﺼﺔ ﺒﺎﻟﻜﺎﺌﻨﺎﺕ‬ ‫ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ‬ ‫ﺤﻴﺎﺓ ﻭﻤﻭﺕ ﺍﻟﻜﺎﺌﻨﺎﺕ‬ ‫ﺍﺭﺴﺎل ﺍﻟﻜﺎﺌﻥ ﺒﺎﻟﻤﺭﺠﻊ ﺍﻭ ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻻﻋﻀﺎﺀ ﺍﻟﻤﺸﺘﺭﻜﺔ‬ ‫ﺍﻟﺤﻘﻭل ﺍﻟﻤﺸﺘﺭﻜﺔ ‪Shared Fields‬‬ ‫ﺍﻟﻁﺭﻕ ﺍﻟﻤﺸﺘﺭﻜﺔ ‪Shared Methods‬‬ ‫ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﻤﺸﺘﺭﻜﺔ ‪Shared Properties‬‬ ‫ﺍﻻﺤﺩﺍﺙ ﺍﻟﻤﺸﺘﺭﻜﺔ ‪Shared Events‬‬ ‫ﺍﻟﻔﺼل ﺍﻟﺭﺍﺒﻊ: ﺍﻟﻭﺭﺍﺜﺔ‬ ‫ﻤﻘﺩﻤﺔ ﺍﻟﻰ ﺍﻟﻭﺭﺍﺜﺔ‬ ‫ﻤﺒﺩﺃ ﺍﻟﻭﺭﺍﺜﺔ‬ ‫ﺘﻁﺒﻴﻕ ﺍﻟﻭﺭﺍﺜﺔ ﺒـ ‪Visual Basic .NET‬‬ ‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻔﺌﺎﺕ ﺍﻟﻭﺍﺭﺜﺔ ﻭﺍﻟﻤﻭﺭﺜﺔ‬ ‫ﻭﺭﺍﺜﺔ ﺍﻻﻋﻀﺎﺀ‬ ‫ﺍﻟﻤﺸﻴﺩﺍﺕ ‪Constructors‬‬ ‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻜﺎﺌﻨﺎﺕ‬ ‫ﺍﻋﺎﺩﺓ ﺍﻟﻘﻴﺎﺩﺓ ‪Overriding‬‬ ‫ﺍﻋﺎﺩﺓ ﻗﻴﺎﺩﺓ ﺍﻟﻁﺭﻕ ﻭﺍﻟﺨﺼﺎﺌﺹ‬ ‫ﺍﺴﺘﺨﺩﺍﻡ ‪MyBase‬‬ ‫ﺍﺴﺘﺨﺩﺍﻡ ‪MyClass‬‬ ‫ﺍﻟﺘﻅﻠﻴل ‪Shadowing‬‬ ‫ﺍﻻﻋﻀﺎﺀ ﺍﻟﻤﺸﺘﺭﻜﺔ ‪Shared Members‬‬
  • 8.
    ‫ﻜﻠﻤﺎﺕ ﻤﺤﺠﻭﺯﺓ ﺍﻀﺎﻓﻴﺔ‬ ‫ﺍﻟﻜﻠﻤﺔﺍﻟﻤﺤﺠﻭﺯﺓ ‪NotInheritable‬‬ ‫ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪MustInherit‬‬ ‫ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪MustOverride‬‬ ‫ﻤﺤﺩﺩﺍﺕ ﺍﻟﻭﺼﻭل‬ ‫ﻗﺎﺒﻠﻴﺔ ﺍﻟﺭﺅﻴﺔ ﻟﻠﻔﺌﺎﺕ‬ ‫ﻗﺎﺒﻠﻴﺔ ﺍﻟﺭﺅﻴﺔ ﻻﻋﻀﺎﺀ ﺍﻟﻔﺌﺎﺕ‬ ‫ﺘﺄﺜﻴﺭ ﻤﺤﺩﺩﺍﺕ ﺍﻟﻭﺼﻭل ﻋﻠﻰ ﺍﻟﻤﺸﻴﺩﺍﺕ‬ ‫ﺍﻟﻔﺼل ﺍﻟﺨﺎﻤﺱ: ﺍﻟﻭﺍﺠﻬﺎﺕ، ﺍﻟﺘﻔﻭﻴﺽ، ﻭﺍﻟﻤﻭﺍﺼﻔﺎﺕ‬ ‫ﺍﻟﻭﺍﺠﻬﺎﺕ‬ ‫ﺒﻨﺎﺀ ﻭﺍﺠﻬﺔ‬ ‫ﺘﻀﻤﻴﻥ ﺍﻟﻭﺍﺠﻬﺔ‬ ‫ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﺍﻟﻭﺍﺠﻬﺔ‬ ‫ﻭﺭﺍﺜﺔ ﺍﻟﻭﺍﺠﻬﺎﺕ‬ ‫ﻭﺍﺠﻬﺎﺕ ﻤﻥ ﺍﻁﺎﺭ ﻋﻤل ‪.NET Framework‬‬ ‫ﺍﻟﻭﺍﺠﻬﺔ ‪IComparable‬‬ ‫ﺍﻟﻭﺍﺠﻬﺔ ‪ICloneable‬‬ ‫ﺍﻟﺘﻔﻭﻴﺽ‬ ‫ﺍﻟﻭﺍﺠﻬﺘﺎﻥ ‪ IEnumerable‬ﻭ ‪IEnumerator‬‬ ‫ﺍﻻﺠﺭﺍﺀﺍﺕ ﺍﻟﺴﺘﺎﺘﻴﻜﻴﺔ‬ ‫ﺍﺠﺭﺍﺀﺍﺕ ﺍﻟﻔﺌﺎﺕ‬ ‫ﻤﺤﺎﻜﺎﺓ ﺍﻻﺤﺩﺍﺙ‬ ‫ﺩﻤﺞ ﺍﻟﺘﻔﻭﻴﻀﺎﺕ‬ ‫ﺍﻟﻤﻭﺍﺼﻔﺎﺕ‬ ‫ﺼﻴﻐﺔ ﻜﺘﺎﺒﺔ ﺍﻟﻤﻭﺍﺼﻔﺎﺕ ﻓﻲ ‪Visual Basic .NET‬‬ ‫ﻤﻭﺍﺼﻔﺎﺕ ﻤﻥ ﺍﻁﺎﺭ ﻋﻤل ‪.NET Framework‬‬ ‫ﺍﻟﻤﻭﺍﺼﻔﺔ ‪Conditional Attribute‬‬ ‫ﺍﻟﻤﻭﺍﺼﻔﺔ ‪DebuggerStepThrough Attribute‬‬ ‫ﺍﻟﻤﻭﺍﺼﻔﺔ ‪Obsolete Attribute‬‬ ‫ﺍﻟﻤﻭﺍﺼﻔﺔ ‪ StructLayout‬ﻭﺍﻟﻤﻭﺍﺼﻔﺔ ‪FieldOffset‬‬ ‫ﺒﻨﺎﺀ ﻤﻭﺍﺼﻔﺎﺕ ﺨﺎﺼﺔ‬ ‫اﻟﺠﺰء اﻟﺜﺎﻧﻲ: اﻃﺎر ﻋﻤﻞ ‪.NET Framework‬‬ ‫ﺍﻟﻔﺼل ﺍﻟﺴﺎﺩﺱ: ﺍﻟﻔﺌﺎﺕ ﺍﻻﺴﺎﺴﻴﺔ‬
  • 9.
    ‫ﺍﻟﻔﺌﺔ ‪System.Object‬‬ ‫ﻁﺭﻕ ﺍﻟﻔﺌﺔ‪Object‬‬ ‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ ﻭﺍﻟﺒﻴﺎﻨﺎﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ ﻤﺭﺓ ﺍﺨﺭﻯ‬ ‫ﺍﻟﺼﻨﺩﻗﺔ ﻭﺍﻟﻼﺼﻨﺩﻗﺔ‬ ‫ﺍﻟﻔﺌﺎﺕ ﺍﻟﺤﺭﻓﻴﺔ‬ ‫ﺍﻟﺨﺼﺎﺌﺹ ﻭﺍﻟﻁﺭﻕ‬ ‫ﻤﻘﺎﺭﻨﺔ ﺍﻟﺤﺭﻭﻑ‬ ‫ﺍﻟﻔﺌﺔ ‪CultureInfo‬‬ ‫ﺍﻟﺒﺤﺙ ﻋﻥ ﺍﻟﺤﺭﻭﻑ‬ ‫ﺍﻟﻔﺌﺎﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪Char‬‬ ‫ﺍﻟﻔﺌﺎﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪StringBuilder‬‬ ‫ﺍﻟﻔﺌﺎﺕ ﺍﻟﻌﺩﺩﻴﺔ‬ ‫ﺍﻟﺨﺼﺎﺌﺹ ﻭﺍﻟﻁﺭﻕ‬ ‫ﺘﻨﺴﻴﻕ ﺍﻻﻋﺩﺍﺩ‬ ‫ﺍﻟﻔﺌﺔ ‪Math‬‬ ‫ﺘﻭﻟﻴﺩ ﺍﻻﻋﺩﺍﺩ ﺍﻟﻌﺸﻭﺍﺌﻴﺔ ‪Random Numbers‬‬ ‫ﻓﺌﺎﺕ ﺍﺨﺭﻯ‬ ‫ﻓﺌﺎﺕ ﺍﻟﻭﻗﺕ ﻭﺍﻟﺘﺎﺭﻴﺦ‬ ‫ﺍﻟﻔﺌﺎﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪Enum‬‬ ‫ﺍﻟﻔﺌﺎﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪Array‬‬ ‫ﻤﺠﺎل ﺍﺴﻤﺎﺀ ‪System.Collections‬‬ ‫ﺍﻟﻭﺍﺠﻬﺎﺕ ‪ ICollection‬ﻭ ‪IList‬‬ ‫ﺍﻟﻔﺌﺔ ‪Stack‬‬ ‫ﺍﻟﻔﺌﺔ ‪Queue‬‬ ‫ﺍﻟﻔﺌﺔ ‪3ArrayList‬‬ ‫ﺍﻟﻔﺼل ﺍﻟﺴﺎﺒﻊ: ﺍﻜﺘﺸﺎﻑ ﺍﻻﺨﻁﺎﺀ‬ ‫ﻓﻜﺭﺓ ﻋﺎﻤﺔ‬ ‫ﺍﺨﻁﺎﺀ ﻭﻗﺕ ﺍﻟﺘﺼﻤﻴﻡ‬ ‫ﺍﺨﻁﺎﺀ ﻭﻗﺕ ﺍﻟﺘﻨﻔﻴﺫ‬ ‫ﺍﻟﺸﻭﺍﺌﺏ‬ ‫ﺍﻟﻜﺎﺌﻥ ‪Exception‬‬ ‫ﺘﻔﺎﺩﻱ ﺍﻻﺴﺘﺜﻨﺎﺀﺍﺕ ‪Catching Exceptions‬‬ ‫ﺭﻤﻲ ﺍﻻﺴﺘﺜﻨﺎﺀﺍﺕ ‪Throwing Exceptions‬‬
  • 10.
    ‫ﺍﻨﺸﺎﺀ ﻓﺌﺎﺕ ﺍﺴﺘﺜﻨﺎﺀﺍﺕﺨﺎﺼﺔ ‪Custom Exceptions‬‬ ‫ﺍﻟﻜﺎﺌﻥ ‪Err‬‬ ‫ﺘﻔﺎﺩﻱ ﺍﻻﺴﺘﺜﻨﺎﺀﺍﺕ‬ ‫ﺭﻤﻲ ﺍﻻﺴﺘﺜﻨﺎﺀﺍﺕ‬ ‫ﺍﻻﺨﺘﻴﺎﺭ ﺒﻴﻥ ‪ Exception‬ﻭ ‪Err‬‬ ‫ﺍﺩﻭﺍﺕ ﺍﻟﺘﻨﻘﻴﺢ ﻤﻥ ‪Visual Studio .NET‬‬ ‫ﺍﺴﺎﻟﻴﺏ ﺍﻟﺘﻨﻔﻴﺫ‬ ‫ﻨﻭﺍﻓﺫ ﺍﺨﺭﻯ‬ ‫ﺍﻻﻋﺩﺍﺩﺍﺕ ‪Configurations‬‬ ‫ﺍﻟﻔﺼل ﺍﻟﺜﺎﻤﻥ: ﺍﻟﻤﻠﻔﺎﺕ ﻭﺍﻟﻤﺠﻠﺩﺍﺕ‬ ‫ﺍﻟﻔﺌﺔ ‪Directory‬‬ ‫ﻁﺭﻕ ﺘﻌﻭﺩ ﺒﻤﺴﺎﺭﺍﺕ‬ ‫ﺍﻟﺒﺤﺙ ﻋﻥ ﺍﻟﻤﻠﻔﺎﺕ ﻭﺍﻟﻤﺠﻠﺩﺍﺕ‬ ‫ﺍﻟﻔﺌﺔ ‪File‬‬ ‫ﺍﻟﻔﺌﺔ ‪Stream‬‬ ‫ﺍﻟﺨﺼﺎﺌﺹ ﻭﺍﻟﻁﺭﻕ ﺍﻟﻤﺸﺘﺭﻜﺔ‬ ‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻤﻠﻔﺎﺕ ﺍﻟﻨﺼﻴﺔ‬ ‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻤﻠﻔﺎﺕ ﺍﻟﺜﻨﺎﺌﻴﺔ‬ ‫ﺘﻜﻭﻴﻥ ‪ Custom Streams‬ﺨﺎﺼﺔ‬ ‫ﻓﺌﺎﺕ ﺍﺨﺭﻯ‬ ‫ﺍﻟﻔﺌﺔ ‪Path‬‬ ‫ﺍﻟﻔﺌﺎﺕ ‪ DirectoryInfo‬ﻭ ‪FileInfo‬‬ ‫ﺍﻟﻔﺼل ﺍﻟﺘﺎﺴﻊ: ﺘﺴﻠﺴل ﺍﻟﻜﺎﺌﻨﺎﺕ ‪Object Serialization‬‬ ‫ﻤﺩﺨﻠﻙ ﺍﻟﻰ ﺘﺴﻠﺴل ﺍﻟﻜﺎﺌﻨﺎﺕ‬ ‫ﻤﺎﻫﻭ ﺍﻟﺘﺴﻠﺴل؟‬ ‫ﺍﻟﺘﺴﻠﺴل ﺒﺎﻟﺼﻴﻐﺔ ﺍﻟﺜﻨﺎﺌﻴﺔ ‪Binary Serialization‬‬ ‫ﺘﺴﻠﺴل ﺍﻨﻭﺍﻉ ﺒﻴﺎﻨﺎﺕ ﻤﺨﺼﺼﺔ )ﻏﻴﺭ ﻗﻴﺎﺴﻴﺔ(‬ ‫ﺨﺭﻴﻁﺔ ﺍﻟﻜﺎﺌﻨﺎﺕ ‪Object Graph‬‬ ‫ﻨﺴﺦ ﺍﻟﻜﺎﺌﻨﺎﺕ‬ ‫ﺍﻨﺸﺎﺀ ‪ Custom Serialization‬ﺨﺎﺼﺔ‬ ‫ﺍﻟﻭﺍﺠﻬﺔ ‪ISerializable‬‬ ‫ﻤﺜﺎل ﺘﻁﺒﻴﻘﻲ‬ ‫ﺍﻟﺘﺴﻠﺴل ﺒﺼﻴﻐﺔ ‪XML‬‬ ‫ﺍﻟﻔﺌﺔ ‪XmlSerializer‬‬
  • 11.
    ‫ﻤﻭﺍﺼﻔﺎﺕ ﺍﻀﺎﻓﻴﺔ‬ ‫ﺍﺤﺩﺍﺙ ﺘﻘﻊﻋﻨﺩ ﻋﻜﺱ ﺍﻟﺘﺴﻠﺴل‬ ‫ﺍﻟﻔﺼل ﺍﻟﻌﺎﺸﺭ: ﻤﺴﺎﺭﺍﺕ ﺍﻟﺘﻨﻔﻴﺫ ‪Threading‬‬ ‫ﻤﻘﺩﻤﺔ ﺍﻟﻰ ﻤﺴﺎﺭﺍﺕ ﺍﻟﺘﻨﻔﻴﺫ‬ ‫ﺍﻨﻭﺍﻉ ﻤﺴﺎﺭﺍﺕ ﺍﻟﺘﻨﻔﻴﺫ‬ ‫ﻤﺘﻰ ﺘﺴﺘﺨﺩﻡ ﻤﺴﺎﺭﺍﺕ ﺍﻟﺘﻨﻔﻴﺫ ﺍﻟﻤﺘﻌﺩﺩﺓ؟‬ ‫ﺍﻨﺸﺎﺀ ﻤﺴﺎﺭ ﺘﻨﻔﻴﺫ‬ ‫ﺍﻟﻁﺭﻕ ﻭﺍﻟﺨﺼﺎﺌﺹ‬ ‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻤﺴﺎﺭﺍﺕ ﺍﻟﺘﻨﻔﻴﺫ‬ ‫ﻤﺸﺎﺭﻜﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺤﻠﻴﺔ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴﺔ‬ ‫ﺍﻟﻤﻭﺍﺼﻔﺔ ‪ThreadStatic Attribute‬‬ ‫ﻭﺤﺩﺓ ﺍﻟﺘﺨﺯﻴﻥ ﺍﻟﻤﺤﻠﻴﺔ ‪TLS‬‬ ‫ﺘﺒﺎﺩل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﻴﻥ ﻤﺴﺎﺭﺍﺕ ﺍﻟﺘﻨﻔﻴﺫ‬ ‫ﺍﻟﺘﺯﺍﻤﻥ ‪Thread Synchronization‬‬ ‫ﺍﻟﺘﺭﻜﻴﺏ ‪SyncLock … End SyncLock‬‬ ‫ﺍﻟﻤﻭﺍﺼﻔﺔ ‪Synchronization‬‬ ‫ﺍﻟﻤﻭﺍﺼﻔﺔ ‪MethodImpl‬‬ ‫ﻓﺌﺎﺕ ﺍﺨﺭﻯ‬ ‫ﺍﻟﻔﺌﺔ ‪ThreadPool‬‬ ‫ﺍﻟﻤﺅﻗﺘﺎﺕ ‪Timers‬‬ ‫ﺍﻟﻤﺅﻗﺕ ‪System.Timers.Timer‬‬ ‫ﺍﻟﻤﺅﻗﺕ ‪System.Threading.Timer‬‬ ‫ﺍﻟﻔﺼل ﺍﻟﺤﺎﺩﻱ ﻋﺸﺭ: ﺍﻟﻤﺠﻤﻌﺎﺕ ‪Assemblies‬‬ ‫ﺍﻟﻭﺤﺩﺍﺕ ﺍﻟﻤﺩﺍﺭﺓ ‪Managed Modules‬‬ ‫ﺍﻟﻤﺠﻤﻌﺎﺕ ‪Assemblies‬‬ ‫ﺍﻟﻤﺠﻤﻌﺎﺕ ﺍﻻﺤﺎﺩﻴﺔ ﻭﺍﻟﻤﺘﻌﺩﺩﺓ ﺍﻟﻤﻠﻔﺎﺕ‬ ‫ﺍﺴﺎﻟﻴﺏ ﺘﻨﻔﻴﺫ ﺍﻟﻤﺠﻤﻌﺎﺕ‬ ‫ﺍﻟﻤﺠﻤﻌﺎﺕ ﺍﻟﺨﺎﺼﺔ ﻭﺍﻟﻤﺸﺘﺭﻜﺔ‬ ‫ﺍﻻﺴﻤﺎﺀ ﺍﻟﻘﻭﻴﺔ ‪Strong Names‬‬ ‫ﺍﻟﻤﻭﺍﺼﻔﺔ ‪Assembly‬‬ ‫ﻤﻠﻔﺎﺕ ﺍﻟﺘﻬﻴﺌﺔ ‪Configuration Files‬‬ ‫ﺍﻨﻭﺍﻉ ﻤﻠﻔﺎﺕ ﺍﻟﺘﻬﻴﺌﺔ‬
  • 12.
    ‫ﺘﻐﻴﻴﺭ ﺍﻻﻋﺩﺍﺩﺍﺕ‬ ‫ﺍﻋﺩﺍﺩﺍﺕ ﻟﻤﻔﺎﺕﺍﻟﺘﻬﻴﺌﺔ‬ ‫ﺍﺴﺘﺨﺩﺍﻡ ﺍﻻﺩﺍﺓ ‪.NET Framework Configuration‬‬ ‫ﺍﺩﻭﺍﺕ ﺍﻟﺘﺭﺠﻤﺔ، ﺍﻟﺭﺒﻁ، ﻭﺍﻟﺘﺴﺠﻴل‬ ‫ﺍﻟﻤﺘﺭﺠﻡ ‪VBC.EXE‬‬ ‫ﺍﻟﺭﺍﺒﻁ ‪AL.EXE‬‬ ‫ﺍﻟﻤﺴﺠل ‪SN.EXE‬‬ ‫ﺍﻟﻤﺴﺠل ‪GACUTIL.EXE‬‬ ‫ﺍﻟﻔﺼل ﺍﻟﺜﺎﻨﻲ ﻋﺸﺭ: ﻓﺌﺎﺕ ﺍﻻﻨﻌﻜﺎﺱ ‪Reflection Classes‬‬ ‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻤﺠﻤﻌﺎﺕ ﻭﺍﻟﻭﺤﺩﺍﺕ ﺍﻟﻤﺩﺍﺭﺓ‬ ‫ﺍﻟﻔﺌﺔ ‪Assembly‬‬ ‫ﺍﻟﻔﺌﺔ ‪Module‬‬ ‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻨﻭﺍﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫ﺍﻟﻔﺌﺔ ‪System.Type‬‬ ‫ﺨﺼﺎﺌﺹ ﺍﻀﺎﻓﻴﺔ‬ ‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻻﻋﻀﺎﺀ‬ ‫ﺍﻟﻔﺌﺔ ﺍﻟﻘﺎﻋﺩﻴﺔ ‪MemberInfo‬‬ ‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺤﻘﻭل‬ ‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻻﺤﺩﺍﺙ‬ ‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻁﺭﻕ‬ ‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻻﺤﺩﺍﺙ‬ ‫ﺍﻟﻭﺴﻴﻁﺎﺕ ‪Parameters‬‬ ‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻜﺎﺌﻨﺎﺕ‬ ‫ﺍﻟﻔﺌﺔ ‪ReflectionExample‬‬ ‫ﺍﺴﻨﺎﺩ/ ﻗﺭﺍﺀﺓ ﻗﻴﻡ ﺍﻟﺤﻘﻭل‬ ‫ﺍﺴﻨﺎﺩ/ ﻗﺭﺍﺀﺓ ﻗﻴﻡ ﺍﻟﺨﺼﺎﺌﺹ‬ ‫ﺍﺴﺘﺩﻋﺎﺀ ﺍﻟﻁﺭﻕ‬ ‫ﻤﻭﺍﻀﻴﻊ ﺍﺨﺭﻯ‬ ‫ﺍﻻﻨﺸﺎﺀ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻲ ﻟﻠﻜﺎﺌﻨﺎﺕ‬ ‫ﻤﻌﺭﻓﺔ ﺍﻻﺠﺭﺍﺀﺍﺕ ﺍﻟﻤﺴﺘﺩﻋﻴﺔ‬ ‫اﻟﺠﺰء اﻟﺜﺎﻟﺚ: ﺗﻄﻮﻳﺮ ﺗﻄﺒﻴﻘﺎت ‪Windows‬‬ ‫ﺍﻟﻔﺼل ﺍﻟﺜﺎﻟﺙ ﻋﺸﺭ: ﻨﻤﺎﺫﺝ ‪Windows Forms‬‬ ‫ﻤﺩﺨﻠﻙ ﺍﻟﻰ ﻨﻤﺎﺫﺝ ‪Windows Forms‬‬
  • 13.
    ‫ﻤﺼﻤﻡ ﺍﻟﻨﻤﺎﺫﺝ ‪FormDesigner‬‬ ‫ﻨﻅﺭﺓ ﺤﻭل ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﻤﻭﻟﺩﺓ‬ ‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻜﺜﺭ ﻤﻥ ﻨﻤﻭﺫﺝ‬ ‫ﻤﺤل ﺍﻟﻔﺌﺔ ‪ Form‬ﻤﻥ ﺍﻻﻋﺭﺍﺏ‬ ‫ﺍﻟﺨﺼﺎﺌﺹ، ﺍﻟﻁﺭﻕ، ﻭﺍﻻﺤﺩﺍﺙ‬ ‫ﺨﺼﺎﺌﺹ ﺍﻟﻨﻤﻭﺫﺝ‬ ‫ﻁﺭﻕ ﺍﻟﻨﻤﻭﺫﺝ‬ ‫ﺍﺤﺩﺍﺙ ﺍﻟﻨﻤﻭﺫﺝ‬ ‫ﻨﻤﺎﺫﺝ ‪MDI Forms‬‬ ‫ﺍﻟﻨﻭﺍﻓﺫ ﺍﻻﺒﻨﺎﺀ ‪Child Windows‬‬ ‫ﺨﺼﺎﺌﺹ ﻭﻁﺭﻕ ﺍﻀﺎﻓﻴﺔ‬ ‫ﺍﻟﻘﻭﺍﺌﻡ ‪Menus‬‬ ‫ﺍﻟﺨﺼﺎﺌﺹ، ﺍﻟﻁﺭﻕ، ﻭﺍﻻﺤﺩﺍﺙ‬ ‫ﺍﻟﻘﻭﺍﺌﻡ ﺍﻟﻤﻨﺒﺜﻘﺔ ‪Popup-Menu‬‬ ‫ﻨﻤﺎﺫﺝ ‪ MDI‬ﻤﺭﺓ ﺍﺨﺭﻯ‬ ‫ﺍﻻﻨﺸﺎﺀ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻲ ﻟﻠﻘﻭﺍﺌﻡ‬ ‫ﻤﻭﺍﻀﻴﻊ ﻤﺘﻘﺩﻤﺔ‬ ‫ﺍﻟﺘﻔﺎﻋل ﻤﻊ ﻨﻭﺍﻓﺫ ‪Modeless‬‬ ‫ﻭﺭﺍﺜﺔ ﺍﻟﻨﻤﺎﺫﺝ ‪Form Inheritance‬‬ ‫ﺍﻟﻨﻤﺎﺫﺝ ﺍﻟﻤﺤﻠﻴﺔ‬ ‫ﺍﻟﻔﺼل ﺍﻟﺭﺍﺒﻊ ﻋﺸﺭ: ﺍﻻﺩﻭﺍﺕ ‪Controls‬‬ ‫ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﻤﺸﺘﺭﻜﺔ‬ ‫ﺍﺴﻡ ﺍﻻﺩﺍﺓ ‪Name‬‬ ‫ﺨﺼﺎﺌﺹ ﺍﻟﻤﻅﻬﺭ‬ ‫ﺨﺼﺎﺌﺹ ﺍﻟﻤﻭﻗﻊ ﻭﺍﻟﺤﺠﻡ‬ ‫ﺨﺼﺎﺌﺹ ﺍﻻﺤﺘﻀﺎﻥ‬ ‫ﺨﺼﺎﺌﺹ ﺍﻻﻟﻭﺍﻥ‬ ‫ﺨﺼﺎﺌﺹ ﺍﻟﺘﺭﻜﻴﺯ‬ ‫ﺨﺼﺎﺌﺹ ﺍﻟﺠﺩﻭﻟﺔ‬ ‫ﺨﺼﺎﺌﺹ ﺍﺨﺭﻯ‬ ‫ﺍﻟﻁﺭﻕ ﺍﻟﻤﺸﺘﺭﻜﺔ‬ ‫ﺍﻻﺤﺩﺍﺙ ﺍﻟﻤﺸﺘﺭﻜﺔ‬ ‫ﺍﺤﺩﺍﺙ ﺍﻟﻔﺄﺭﺓ‬
  • 14.
    ‫ﺍﺤﺩﺍﺙ ﻟﻭﺤﺔ ﺍﻟﻤﻔﺎﺘﻴﺢ‬ ‫ﺍﺤﺩﺍﺙﺍﻟﺘﺭﻜﻴﺯ‬ ‫ﺍﺤﺩﺍﺙ ﺍﺨﺭﻯ‬ ‫ﻋﺭﺽ ﺴﺭﻴﻊ ﻟﻼﺩﻭﺍﺕ‬ ‫ﺍﻻﺩﺍﺓ ‪Label‬‬ ‫ﺍﻻﺩﺍﺓ ‪LinkLabel‬‬ ‫ﺍﻻﺩﺍﺓ ‪TextBox‬‬ ‫ﺍﻻﺩﺍﺓ ‪Button‬‬ ‫ﺍﻻﺩﺍﺓ ‪CheckBox‬‬ ‫ﺍﻻﺩﺍﺓ ‪RadioButton‬‬ ‫ﺍﻻﺩﺍﺓ ‪ListBox‬‬ ‫ﺍﻻﺩﺍﺓ ‪CheckedListBox‬‬ ‫ﺍﻻﺩﺍﺓ ‪ComboBox‬‬ ‫ﺍﻻﺩﺍﺓ ‪ImageList‬‬ ‫ﺍﻻﺩﺍﺓ ‪TreeView‬‬ ‫ﺍﻻﺩﺍﺓ ‪ListView‬‬ ‫ﺍﻻﺩﺍﺘﻴﻥ ‪ ToolBar‬ﻭ ‪StatusBar‬‬ ‫ﺍﻻﺩﺍﺓ ‪Splitter‬‬ ‫ﺍﺩﻭﺍﺕ ﺼﻨﺎﺩﻴﻕ ﺍﻟﺤﻭﺍﺭ ﺍﻟﺸﺎﺌﻌﺔ‬ ‫ﺍﺩﻭﺍﺕ ﺍﻟﻤﺯﻭﺩﺍﺕ‬ ‫ﺍﺩﻭﺍﺕ ﺍﺨﺭﻯ‬ ‫ﺘﻘﻨﻴﺔ ﺍﻟﻤﺭﺁﺓ‬ ‫ﺍﻟﺨﺎﺼﻴﺔ ‪RightToLeft‬‬ ‫ﻗﺼﻭﺭ ﺍﻟﺨﺎﺼﻴﺔ ‪RightToLeft‬‬ ‫ﻤﺩﺨﻠﻙ ﺍﻟﻰ ﺘﻘﻨﻴﺔ ﺍﻟﻤﺭﺁﺓ‬ ‫ﺘﻁﺒﻴﻕ ﺘﻘﻨﻴﺔ ﺍﻟﻤﺭﺁﺓ ﺒـ ‪Visual Basic .NET‬‬ ‫ﻤﺸﺎﻜل ﺍﻀﺎﻓﻴﺔ‬ ‫ﺍﺩﻭﺍﺕ ﺼﻨﺎﺩﻴﻕ ﺍﻟﺤﻭﺍﺭ ﺍﻟﺸﺎﺌﻌﺔ‬ ‫ﺼﻨﺎﺩﻴﻕ ﺍﻟﺭﺴﺎﺌل‬ ‫ﺍﻟﻔﺼل ﺍﻟﺨﺎﻤﺱ ﻋﺸﺭ: ﻤﺒﺎﺩﺉ +‪GDI‬‬ ‫ﺍﻟﺭﺴﻡ ﺍﻟﻤﺘﻘﺩﻡ‬ ‫ﺍﻟﻜﺎﺌﻥ ‪Graphics‬‬ ‫ﺭﺴﻡ ﺍﻟﺨﻁﻭﻁ، ﺍﻟﻤﺴﺘﻁﻴﻼﺕ، ﻭﺍﻟﺩﻭﺍﺌﺭ‬ ‫ﺭﺴﻡ ﺍﻟﻤﻨﺤﻨﻴﺎﺕ ﺍﻟﻤﻌﻘﺩﺓ‬
  • 15.
    ‫ﻜﺎﺌﻥ ﺍﻟﻘﻠﻡ ‪Pen‬‬ ‫ﻜﺎﺌﻥﻤﺴﺎﺭ ﺍﻟﺭﺴﻡ ‪GraphicsPath‬‬ ‫ﺍﻟﺘﻌﺒﺌﺔ‬ ‫ﻜﺎﺌﻥ ﺍﻟﻔﺭﺸﺎﺓ ‪Brush‬‬ ‫ﺍﻨﻅﻤﺔ ﺍﻟﻘﻴﺎﺱ‬ ‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺼﻭﺭ‬ ‫ﺘﺤﻤﻴل ﻭﺤﻔﻅ ﺍﻟﺼﻭﺭ‬ ‫ﻋﺭﺽ ﺍﻟﺼﻭﺭ‬ ‫ﻋﻜﺱ، ﻗﻠﺏ، ﻭﺴﺤﺏ ﺍﻟﺼﻭﺭ‬ ‫ﺘﺤﺩﻴﺩ ﺍﻻﻟﻭﺍﻥ‬ ‫ﺍﻟﺭﻤﻭﺯ ‪Icons‬‬ ‫ﺍﻟﻤﺨﺭﺠﺎﺕ ﺍﻟﻨﺼﻴﺔ‬ ‫ﻋﻭﺍﺌل ﺍﻟﺨﻁﻭﻁ‬ ‫ﺭﺴﻡ ﺍﻟﻨﺼﻭﺹ‬ ‫ﺍﻟﺘﻔﺎﻑ ﺍﻟﻨﺹ‬ ‫ﺍﻟﻜﺎﺌﻥ ‪StringFormat‬‬ ‫ﻋﻭﺩﺓ ﺍﻟﻰ ﺍﻻﺩﻭﺍﺕ ‪Controls‬‬ ‫ﺍﻟﻔﺼل ﺍﻟﺴﺎﺩﺱ ﻋﺸﺭ: ﻤﻭﺍﻀﻴﻊ ﻤﺘﻘﺩﻤﺔ‬ ‫ﺘﻁﻭﻴﺭ ﺍﺩﻭﺍﺕ ﺨﺎﺼﺔ‬ ‫ﻭﺭﺍﺜﺔ ﺍﺩﺍﺓ‬ ‫ﺤﻀﻥ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻻﺩﻭﺍﺕ‬ ‫ﺍﻨﺸﺎﺀ ﺍﺩﺍﺓ ﻤﺴﺘﻘﻠﺔ‬ ‫ﻟﻤﺴﺎﺕ ﻓﻨﻴﺔ ﺍﻀﺎﻓﻴﺔ‬ ‫ﺘﻁﻭﻴﺭ ﺨﺩﻤﺎﺕ ‪Windows‬‬ ‫ﻤﻘﺩﻤﺔ ﺍﻟﻰ ﺨﺩﻤﺎﺕ ‪Windows‬‬ ‫ﺍﻨﺸﺎﺀ ﻤﺸﺎﺭﻴﻊ ﻤﻥ ﻨﻭﻉ ‪Windows Service‬‬ ‫ﺘﺼﺤﻴﺢ ﺍﻟﺸﻴﻔﺭﺓ‬ ‫ﺍﻟﻔﺌﺔ ‪System.IO.FileSystemWatcher‬‬ ‫ﻜﺘﺎﺒﺔ ﺍﻟﺸﻴﻔﺭﺍﺕ‬ ‫ﺘﺴﺠﻴل ﺍﻟﺨﺩﻤﺔ‬ ‫ﺍﻻﺩﺍﺓ ‪InstallUtil.EXE‬‬ ‫ﻓﺌﺎﺕ ﺍﺨﺭﻯ‬ ‫ﺍﻟﻔﺌﺔ ‪Application‬‬
  • 16.
    ‫ﺍﻟﻔﺌﺔ ‪Cursor‬‬ ‫ﺍﻟﻔﺌﺔ ‪SendKeys‬‬ ‫ﺍﻟﻔﺌﺘﺎﻥ‪ Registry‬ﻭ ‪RegistryKey‬‬ ‫ﺍﻟﻔﺌﺔ ‪Help‬‬ ‫اﻟﺠﺰء اﻟﺮاﺑﻊ: ﺑﺮﻣﺠﺔ ﻗﻮاﻋﺪ اﻟﺒﻴﺎﻧﺎت‬ ‫ﺍﻟﻔﺼل ﺍﻟﺴﺎﺒﻊ ﻋﺸﺭ: ﺍﺴﺘﺨﺩﺍﻡ ‪ADO.NET‬‬ ‫ﻤﺩﺨﻠﻙ ﺍﻟﻰ ‪ADO.NET‬‬ ‫ﺍﻟﻭﻀﻊ ﺍﻟﻤﺘﺼل ﻭﺍﻟﻭﻀﻊ ﺍﻟﻤﻨﻔﺼل‬ ‫ﻤﺯﻭﺩﺍﺕ ‪.NET Data Providers‬‬ ‫ﻓﺌﺎﺕ ‪ADO.NET‬‬ ‫ﻜﺎﺌﻥ ﺍﻻﺘﺼﺎل ‪Connection‬‬ ‫ﺍﻨﺸﺎﺀ ﻜﺎﺌﻥ ﺍﺘﺼﺎل‬ ‫ﻨﺹ ﺍﻻﺘﺼﺎل‬ ‫ﻓﺘﺢ ﻭﺍﻏﻼﻕ ﺍﻻﺘﺼﺎﻻﺕ‬ ‫ﻜﺎﺌﻥ ﺍﻻﻭﺍﻤﺭ ‪Command‬‬ ‫ﺍﻨﺸﺎﺀ ﻜﺎﺌﻥ ﺍﻭﺍﻤﺭ‬ ‫ﺍﻟﺭﺒﻁ ﻤﻊ ﺍﺘﺼﺎل‬ ‫ﺘﻨﻔﻴﺫ ﺠﻤل ﺍﻻﺴﺘﻌﻼﻡ ‪SQL‬‬ ‫ﻗﺭﺍﺌﺔ ﺍﻟﺴﺠﻼﺕ‬ ‫ﻜﺎﺌﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪DataReader‬‬ ‫ﺍﻨﺸﺎﺀ ﻜﺎﺌﻥ ﺒﻴﺎﻨﺎﺕ‬ ‫ﻗﺭﺍﺌﺔ ﺍﻟﺴﺠﻼﺕ‬ ‫ﺨﺎﺹ ﺒﻤﺴﺘﺨﺩﻤﻲ ® ‪Microsoft SQL Server‬‬ ‫ﻗﺭﺍﺌﺔ ﻨﺘﺎﺌﺞ ﻤﺘﻌﺩﺩﺓ‬ ‫ﺍﻟﻔﺼل ﺍﻟﺜﺎﻤﻥ ﻋﺸﺭ: ‪ ADO.NET‬ﻟﻠﻭﻀﻊ ﺍﻟﻤﻨﻔﺼل‬ ‫ﻜﺎﺌﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪DataSet‬‬ ‫ﺍﻟﻔﺌﺔ ‪DataTable‬‬ ‫ﺍﻟﻔﺌﺔ ‪DataRow‬‬ ‫ﺍﻟﻔﺌﺔ ‪DataColumn‬‬ ‫ﺍﻟﻔﺌﺔ ‪DataRelation‬‬ ‫ﺍﻨﺸﺎﺀ ﻜﺎﺌﻥ ﺒﻴﺎﻨﺎﺕ ‪ DataSet‬ﻤﻥ ﺍﻟﺼﻔﺭ‬ ‫ﻜﺎﺌﻥ ﺍﻟﻤﺤﻭل ‪DataAdapter‬‬ ‫ﺴﻴﻨﺎﺭﻴﻭ ﺍﻟﻭﻀﻊ ﺍﻟﻤﻨﻔﺼل‬
  • 17.
    ‫ﺍﻨﺸﺎﺀ ﻜﺎﺌﻥ ﻤﺤﻭل‪DataAdapter‬‬ ‫ﺍﻟﺭﺒﻁ ﻤﻊ ﺍﺘﺼﺎل‬ ‫ﻗﺭﺍﺌﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫ﺘﺤﺩﻴﺙ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫ﺘﺨﺼﻴﺹ ﺍﻓﻀل ﻟﻠﺨﺼﺎﺌﺹ ‪xxxCommand‬‬ ‫ﺍﺘﻘﺎﺀ ﺸﺭ ﺍﻟﺘﻌﺎﺭﻀﺎﺕ‬ ‫ﻋﺭﺽ ﺍﻟﺘﻌﺎﺭﻀﺎﺕ‬ ‫ﺍﻟﺤﺩﺙ ‪RowUpdated‬‬ ‫ﺍﻟﻔﺼل ﺍﻟﺘﺎﺴﻊ ﻋﺸﺭ: ﺭﺒﻁ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﺍﻟﺘﻜﺎﻤل ﻤﻊ ‪XML‬‬ ‫ﺭﺒﻁ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫ﺍﻨﻭﺍﻉ ﺍﻟﺭﺒﻁ‬ ‫ﻤﻴﻜﺎﻨﻴﻜﻴﺔ ﺍﻟﺭﺒﻁ‬ ‫ﺍﻟﺭﺒﻁ ﺍﻟﻰ ﻤﺼﻔﻭﻓﺔ‬ ‫ﺍﻟﺭﺒﻁ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪ADO.NET‬‬ ‫ﺍﻟﺭﺒﻁ ﺍﻟﻤﻌﻘﺩ ‪Complex Binding‬‬ ‫ﻓﺌﺎﺕ ﺨﺎﺼﺔ ﺒـ ‪XML‬‬ ‫ﺍﻟﻔﺌﺔ ‪XmlTextReader‬‬ ‫ﺍﻟﻔﺌﺔ ‪XmlTextWriter‬‬ ‫ﺘﻜﺎﻤل ‪ ADO.NET‬ﻭ ‪XML‬‬ ‫ﻜﺘﺎﺒﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺼﻴﻐﺔ ‪XML‬‬ ‫ﻗﺭﺍﺌﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺼﻴﻐﺔ ‪XML‬‬ ‫اﻟﺠﺰء اﻟﺨﺎﻣﺲ: ﺑﺮﻣﺠﺔ وﻳﺐ‬ ‫ﺍﻟﻔﺼل ﺍﻟ ﻌﺸﺭﻭﻥ: ﺘﻁﺒﻴﻘﺎﺕ ‪(1) ASP.NET‬‬ ‫ﺍﻟﺨﺎﺩﻡ ‪IIS‬‬ ‫ﺘﺭﻜﻴﺏ ﺍﻟﺨﺎﺩﻡ ‪IIS‬‬ ‫ﺍﻻﺩﻟﺔ ﺍﻟﻭﻫﻤﻴﺔ‬ ‫ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﺍﻻﺩﻟﺔ ﺍﻟﻭﻫﻤﻴﺔ‬ ‫ﻤﺩﺨﻠﻙ ﺍﻟﻰ ﻨﻤﺎﺫﺝ ‪Web Forms‬‬ ‫ﺍﻨﺸﺎﺀ ﺍﻟﻤﺸﺭﻭﻉ‬ ‫ﻀﺒﻁ ﺍﻻﻋﺩﺍﺩﺍﺕ ﺍﻟﺭﺌﻴﺴﺔ‬ ‫ﻜﺘﺎﺒﺔ ﺍﻟﺸﻴﻔﺭﺍﺕ‬ ‫ﺘﺤﻠﻴل ﺍﻟﺸﻴﻔﺭﺓ‬ ‫ﺍﺴﺎﻟﻴﺏ ﺘﻨﻔﻴﺫ ﺍﻟﺼﻔﺤﺔ‬
  • 18.
    ‫ﺍﻟﺨﻼﺼﺔ‬ ‫ﺍﻟﻔﺌﺔ ‪Page‬‬ ‫ﺨﺼﺎﺌﺹ ﺼﻔﺤﺔﺍﻟﻨﻤﻭﺫﺝ‬ ‫ﻁﺭﻕ ﺼﻔﺤﺔ ﺍﻟﻨﻤﻭﺫﺝ‬ ‫ﺍﺤﺩﺍﺙ ﺼﻔﺤﺔ ﺍﻟﻨﻤﻭﺫﺝ‬ ‫ﺍﻻﺩﻭﺍﺕ‬ ‫ﻭﺴﻭﻡ ﺍﻀﺎﻓﻴﺔ‬ ‫ﺍﺩﻭﺍﺕ ‪Web Forms Controls‬‬ ‫ﺍﺩﻭﺍﺕ ‪HTML Forms Controls‬‬ ‫ﺍﺩﻭﺍﺕ ﺍﻟﺘﺤﻘﻕ ‪Validation‬‬ ‫ﺍﻟﻔﺼل ﺍﻟﺤﺎﺩﻱ ﻭﺍﻟﻌﺸﺭﻭﻥ: ﺘﻁﺒﻴﻘﺎﺕ ‪(2) ASP.NET‬‬ ‫ﻜﺎﺌﻨﺎﺕ ﺼﻔﺤﺎﺕ ‪ ASP.NET‬ﺍﻻﺴﺎﺴﻴﺔ‬ ‫ﺍﻟﻜﺎﺌﻥ ‪HttpRequest‬‬ ‫ﺍﻟﻜﺎﺌﻥ ‪HttpResponse‬‬ ‫ﺍﻟﻜﺎﺌﻥ ‪HttpServerUtility‬‬ ‫ﺍﻟﻜﺎﺌﻥ ‪HttpApplicationState‬‬ ‫ﺍﻟﻜﺎﺌﻥ ‪HttpSessionState‬‬ ‫ﺍﻟﻤﻠﻑ ‪Global.asax‬‬ ‫ﺍﻻﺠﺭﺍﺀﺍﺕ )(‪ xxxStart‬ﻭ )(‪xxxEnd‬‬ ‫ﺍﻻﺠﺭﺍﺀ )(‪Global_Error‬‬ ‫ﺍﻻﻤﺎﻥ ‪Security‬‬ ‫ﻤﺩﺨﻠﻙ ﺍﻟﻰ ﺍﻟﺼﻼﺤﻴﺎﺕ‬ ‫ﺍﻭﻀﺎﻉ ﺍﻟﺘﺼﺩﻴﻕ ﻓﻲ ‪ASP.NET‬‬ ‫ﻤﻠﻔﺎﺕ ﺍﻟﺘﻬﻴﺌﺔ‬ ‫ﺍﻟﻭﻀﻊ ‪ Forms‬ﻟﻠﺘﺼﺩﻴﻕ‬ ‫ﺍﻟﻭﺴﻡ >‪<credentials‬‬ ‫ﺼﻔﺤﺔ ﺘﺴﺠﻴل ﺍﻟﺩﺨﻭل ‪Login‬‬ ‫ﻤﻭﺍﻀﻴﻊ ﻤﺘﻘﺩﻤﺔ‬ ‫ﺍﻟﺘﺨﺯﻴﻥ ‪Caching‬‬ ‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﻤﺔ‬ ‫ﺤﻤﺎﻴﺔ ﺍﻟﺼﻭﺭ‬ ‫ﺍﻻﻨﺸﺎﺀ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻲ ﻟﻠﺼﻭﺭ‬ ‫ﻭﺤﺩﺍﺕ ‪HTTP Modules‬‬ ‫ﺍﻟﻔﺼل ﺍﻟﺜﺎﻨﻲ ﻭﺍﻟﻌﺸﺭﻭﻥ: ﺨﺩﻤﺎﺕ ﻭﻴﺏ ‪Web Services‬‬
  • 19.
    ‫ﻤﺩﺨﻠﻙ ﺍﻟﻰ ﺨﺩﻤﺎﺕﻭﻴﺏ‬ ‫ﻜﻴﻑ ﺘﻌﻤل ﺨﺩﻤﺎﺕ ﻭﻴﺏ؟‬ ‫ﺒﻨﺎﺀ ﺨﺩﻤﺔ ﻭﻴﺏ‬ ‫ﺍﻨﺸﺎﺀ ﺍﻟﻤﺸﺭﻭﻉ‬ ‫ﻜﺘﺎﺒﺔ ﺍﻟﺸﻴﻔﺭﺓ‬ ‫ﺍﺨﺘﺒﺎﺭ ﺍﻟﺨﺩﻤﺔ ﻤﻥ ﺍﻟﻤﺘﺼﻔﺢ‬ ‫ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺨﺩﻤﺔ‬ ‫ﻜﻴﻑ ﺘﻡ ﺍﻟﺭﺒﻁ؟‬ ‫ﺘﺤﺩﻴﺙ ﺍﻟﺨﺩﻤﺔ‬ ‫ﻤﻌﻠﻭﻤﺎﺕ ﺍﻀﺎﻓﻴﺔ‬ ‫اﻟﻤﻼﺣﻖ‬ ‫ﺍﻟﻤﻠﺤﻕ ﺃ: ﻟﻐﺔ ﻭﺼﻑ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪XML‬‬ ‫ﺍﻟﻤﻠﺤﻕ ﺏ: ﻟﻐﺔ ﺍﻻﺴﺘﻌﻼﻡ ‪SQ L‬‬
  • 21.
    ‫0‬ ‫ﺗﻤﻬﻴﺪ‬ ‫ﺗﻘﺪﻳﻢ‬ ‫ﻟﻘﺩ ﺍﺴﻌﺩﻨﻲ ﺨﺒﺭﺍﻥ ﺘﺭﻜﻲ ﺍﻟﻌﺴﻴﺭﻱ ﻗﺎﻡ ﺒﻜﺘﺎﺒﺔ ﻜﺘﺎﺒﺎ ﺠﺩﻴﺩﺍ ﻋﻥ ﻟﻐﺔ ‪ Visual Basic .NET‬ﻭﺍﻟﺘـﻲ ﺘﻌﺘﺒـﺭ‬ ‫ﻟﻐﺔ ﺍﻟﻤﺴﺘﻘﺒل ﻟﻠﻤﻁﻭﺭﻴﻥ ﻭﺍﻟﻤﺒﺭﻤﺠﻴﻥ، ﻭﺍﻥ ﻜﻨﺕ ﻻ ﺘﻌﻠﻡ ﻤﻥ ﻫﻭ ﺘﺭﻜﻲ ﺍﻟﻌﺴﻴﺭﻱ، ﻓﺩﻉ ﻫﺫﺍ ﺍﻟﻜﺘـﺎﺏ ﻴﻌﺭﻓـﻙ‬ ‫ﺒﻪ؛ ﻴﻜﻔﻴﻙ ﻤﻘﺎﻻﺘﻪ ﺍﻟﺘﻲ ﺘﻤﻠﺘﺊ ﺒﻬﺎ ﺍﻟﻤﻭﺍﻗﻊ ﺍﻟﻌﺭﺒﻴﺔ ﺤﻭل ﺘﻘﻨﻴﺔ ‪ ،.NET‬ﻭﻻﺘﻨﺴـﻰ ﺍﻨـﻪ ﺍﻟﻤﺅﺴـﺱ ﻟﻠﻤﻭﻗـﻊ‬ ‫ﺍﻟﺸﻬﻴﺭ ﺸﺒﻜﺔ ﺍﻟﻤﻁﻭﺭﻭﻥ ﺍﻟﻌﺭﺏ )‪ (dev4arabs.com‬ﻭﻜﺎﺘﺏ ﻟﺠﻤﻴﻊ ﺍﻟﺸﻴﻔﺭﺍﺕ ﺍﻟﻤﺼـﺩﺭﻴﺔ ﺍﻟﺘـﻲ ﺘﻨـﺒﺽ‬ ‫ﺍﻟﻤﻭﻗﻊ ﺒﺎﻟﺤﻴﺎﺓ، ﻭﻤﺎ ﻴﺠﻌﻠﻨﻲ ﺃﺸﻌﺭ ﺒﺎﻟﻔﺨﺭ ﻫﻭ ﺃﻥ ﺍﻟﻜﺎﺘﺏ ﻋﺭﺒﻲ ﻭﻴﻭﺠﻪ ﺨﺒﺭﺘﻪ ﻭﻤﻌﺭﻓﺘﻪ ﻟﻠﻌﺭﺏ.‬ ‫ﻴﺘﻤﺘﻊ ﺍﻷﺥ ﺘﺭﻜﻲ ﺒﻤﺯﺍﻴﺎ ﺨﺎﺼﺔ ﺴﻭﺍﺀ ﻜﺎﻥ ﻤﺒﺭﻤﺠﺎ ﺍﻭ ﻜﺎﺘﺒﺎ، ﻓﻠﺩﻴـﻪ ﻤـﻥ ﺍﻻﺴـﻠﻭﺏ ﺍﻟـﺫﻱ ﻴﺠﻌﻠـﻙ‬ ‫ﺘﺴﺘﻭﻋﺏ ﺍﻻﻤﻭﺭ ﺍﻟﻤﻌﻘﺩﺓ ﻭﻜﺎﻨﻬﺎ ﻤﻌﺎﺩﻟﺔ 1+1=2 ! ﻭﺍﻵﻥ ﺃﺭﻯ ﺃﻨﻪ ﺍﻨﺠﺯ ﻤﺸﺭﻭﻋﺎ )ﻜﻤﺎ ﻴﻠﻘﺏ ﻜﺘﺎﺒـﻪ( ﻴﻌﺘﺒـﺭ‬ ‫ﺍﻭل ﻜﺘﺎﺏ ﻤﻥ ﻤﺅﻟﻑ ﻋﺭﺒﻲ ﺤﻭل ﺘﻘﻨﻴﺔ ‪ ،Microsoft .NET‬ﻜﻤـﺎ ﺴـﻁﺭ ﻤﺠﻤﻭﻋـﺔ ﻤـﻥ ﺍﻟﺼـﻔﺤﺎﺕ‬ ‫ﻭﺍﻟﻤﻭﺠﻪ ﺨﺼﻴﺼﺎ ﻟﻠﻤﻁﻭﺭ ﺍﻟﻌﺭﺒﻲ.‬ ‫ﻜﺨﺒﻴﺭ ﺘﺼﻤﻴﻡ ﻭﺘﻁﻭﻴﺭ ﻤﻭﺍﻗﻊ، ﺃﺭﻯ ﺒﺄﻥ ﺍﻟﻜﺘﺎﺏ ﺴﻴﻔﻴﺩ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺍﻟﻌـﺭﺏ ﺍﻟﺘـﺎﺌﻬﻴﻥ ﻓـﻲ‬ ‫ﺘﻘﻨﻴﺔ ‪ ،.NET‬ﻓﻬﺫﻩ ﺍﻟﺘﻘﻨﻴﺔ ﺘﻌﺘﺒﺭ ﺘﻘﻨﻴﺔ ﺍﻟﻤﺴﺘﻘﺒل ﻟﺘﻁﻭﻴﺭ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﻭﻤﻭﺍﻗﻊ ﺍﻹﻨﺘﺭﻨﺕ، ﻭﻫﻲ ﻗﻭﻴﺔ ﺠـﺩﺍ ﻭﻟﻬـﺎ‬ ‫ﻤﻥ ﺍﻻﻤﻜﺎﻨﻴﺎﺕ ﻤﺎ ﻴﻔﻭﻕ ﺍﻟﺘﻭﻗﻌﺎﺕ، ﻭﻟﻜـﻥ ﻤﺴـﺎﻟﺔ ﺍﺴـﺘﻴﻌﺎﺒﻬﺎ ﺴـﻴﻜﻭﻥ ﺼـﻌﺒﺎ ﻋﻠـﻰ ﺍﻏﻠـﺏ ﺍﻟﻤﺒـﺭﻤﺠﻴﻥ‬ ‫ﺍﻟﻤﺴﺘﺠﺩﻴﻥ ﻭﺍﻟﻤﺨﻀﺭﻤﻴﻥ ﺍﻴﻀﺎ!، ﻫﺫﺍ ﻭﺍﻥ ﻋﻠﻤﺕ ﺍﻨﻬﺎ ﻤﻥ ﺍﺤﺩﺙ ﺍﻟﺘﻘﻨﻴﺎﺕ ﺍﻟﺼﺎﺩﺭﺓ ﻤـﻥ ﻤﻌﺎﻤـل ﺭﻴـﺩﻤﻭﻥ‬ ‫ﺒﻭﻻﻴﺔ ﻭﺍﺸﻨﻁﻥ )ﺍﻋﻨﻲ ﻤﻥ ﺸﺭﻜﺔ ‪ ،(Microsoft‬ﻭﻭﺠﻭﺩ ﻤﺼﺩﺭ ﻻﺘﻘﺎﻨﻬﺎ ﻴﺤﺘﺎﺝ ﺍﻟـﻰ ﺠﻬـﺩ ﺠﻬﻴـﺩ، ﻭﻤـﻥ‬ ‫ﺍﻟﻨﺎﺩﺭ ﺍﻟﺤﺼﻭل ﻋﻠﻰ ﻤﺭﺠﻊ ﻟﻬﺎ ﺒﺎﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ، ﻓﻜل ﺍﻟﻜﺘﺏ ﺍﻟﻌﺭﺒﻴﺔ ﻭﺍﻟﺨﺎﺼﺔ ﺒﺘﻘﻨﻴﺔ ‪ .NET‬ﻤﺘﺭﺠﻤﺔ، ﻓﻤـﺎ‬ ‫ﺒﺎﻟﻜﻡ ﺇﺫﺍ ﻜﺎﻥ ﺍﻟﻜﺎﺘﺏ ﻋﺭﺒﻲ ﻴﻌﺭﻑ ﻜﻴﻑ ﻨﻔﻜﺭ ﻭﻤﺎﻫﻲ ﻤﺘﻁﻠﺒﺎﺘﻨﺎ ﻭﺇﻟﻰ ﻤﺎﺫﺍ ﻨﺘﻁﻠﻊ ﺃﻭ ﻨﺘﻭﻗﻊ ﻤﻥ ﻜﺘـﺎﺏ ﺒﻬـﺫﺍ‬ ‫ﺍﻟﺤﺠﻡ ﻭﺍﻟﺘﺨﺼﺹ.‬ ‫ﻴﺘﻤﻴﺯ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﺒﺎﻟﻨﻤﻁ ﺍﻻﺴﺘﻴﻌﺎﺒﻲ ﺍﻟﺫﻱ ﻴﺘﻌﻤﺩﻩ ﺍﻟﻤﺅﻟﻑ، ﻓﻬﻭ ﻴﺭﻜﺯ ﻋﻠﻰ ﺍﻟﺴـﻬﻭﻟﺔ ﻭﺍﻟﻤﻨﻁـﻕ ﻓـﻲ‬ ‫ﺍﻟﺘﺴﻠﺴل ﻹﻴﺼﺎل ﺍﻟﻤﻌﻠﻭﻤﺔ ﻟﻠﻘﺎﺭﺉ ﻭﻫﺫﺍ ﻤﺎ ﻴﻌﺭﻑ ﻋﻥ ﺍﻟﻜﺎﺘﺏ، ﻓﺄﺴﻠﻭﺒﻪ ﺴﻠﺱ ﻭﺩﺍﺌﻤـﺎ ﻤـﺎ ﻴﺤـﺎﻭل ﺍﻟﻨـﺯﻭل‬ ‫ﹰ‬ ‫ﻟﻤﺴﺘﻭﻯ ﺍﻟﻘﺎﺭﺉ ﺜﻡ ﻴﺭﺘﻘﻲ ﺒﻪ ﻜﻠﻤﺎ ﺍﺴﺘﻤﺭ ﻓﻲ ﺍﻟﻘﺭﺍﺀﺓ، ﻜﻤﺎ ﺍﻨﻪ ﻴﻀﻔﻲ ﻋﻠﻰ ﺍﻟﻜﺘﺎﺏ ﺍﺴﻠﻭﺏ ﺍﻟﻤﺤـﺎﻭﺭﺓ ﻤﻤـﺎ‬ ‫ﻴﻭﺤﻲ ﺍﻥ ﺍﻟﻤﺅﻟﻑ ﺍﻤﺎﻤﻙ ﻭﻴﻨﺎﻗﺸﻙ ﻓﻲ ﺍﻟﻤﻭﺍﻀﻴﻊ ﻭﻜﺄﻨﻙ ﻓﻲ ﻗﺎﻋﺔ ﻤﺤـﺎﻅﺭﺓ، ﺍﻀـﻑ ﺍﻟـﻰ ﺫﻟـﻙ ﺍﻻﻤﺜﻠـﺔ‬ ‫ﺍﻟﻔﻭﺭﻴﺔ ﺍﻟﺘﻲ ﻴﻌﺭﻀﻬﺎ ﻋﻨﺩ ﺍﻟﺤﺩﻴﺙ ﺒﻌﺩ ﺸﺭﺡ ﻜل ﻨﻘﻁﺔ، ﻓﻬﻲ ﻟﻴﺴﺕ ﻜﺒﻴﺭﺓ ﻟﻴﺼﻌﺏ ﺘﺘﺒﻌﻬﺎ.‬ ‫ﺍﻤﺎ ﻋﻥ ﺍﻟﻤﺴﺎﻟﺔ ﺍﻟﺘﺠﺎﺭﻴﺔ، ﻓﻭﺍﻀﺢ ﻤﻥ ﺍﻷﺴﻠﻭﺏ ﻓﻲ ﺍﻟﻜﺘﺎﺒﺔ ﻭﻭﻓﺭﺓ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺒﺄﻥ ﺍﻟﻜﺎﺘـﺏ ﺤـﺭﻴﺹ‬ ‫ﻋﻠﻰ ﺇﻴﺼﺎل ﺃﻜﺒﺭ ﻗﺩﺭ ﻤﻥ ﺍﻟﻤﻌﺭﻓﺔ ﻟﻴﺠﻌل ﺍﻟﻘﺎﺭﺉ ﻴﺘﻌﻠﻡ ﺃﻜﺜﺭ ﻗﺩﺭ ﻤﻤﻜﻥ ﻭﺒﺎﻟﺘﺎﻟﻲ ﻴﺴﺘﻁﻴﻊ ﺘﻁﺒﻴﻕ ﻤـﺎ ﺘﻌﻠﻤـﻪ‬ ‫ﻭﺍﻹﺴﺘﻔﺎﺩﺓ ﻤﻥ ﻗﺭﺍﺀﺓ ﺍﻟﻜﺘﺎﺏ، ﻓﻼ ﻴﻘﻭﻡ ﺒﻨﺴﺦ ﺠﺩﺍﻭل ﻭﺜﺎﺌﻕ ‪ .NET Documentation‬ﻟﻠﺘﻜﺜﻴﺭ ﻤـﻥ ﻋـﺩﺩ‬
  • 22.
    ‫ب‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺍﻟﺼﻔﺤﺎﺕ ﻭﺯﻴﺎﺩﺓﺍﻟﺩﺨل ﻜﻤﺎ ﺘﻔﻌل ﺍﻏﻠﺏ ﺍﻟﻜﺘﺏ ﺍﻟﻤﻨﺘﺸﺭﺓ ﻓـﻲ ﺍﻻﺴـﻭﺍﻕ، ﻓﻤﻌﻅـﻡ ﻫـﺫﻩ ﺍﻟﻜﺘـﺏ ﺘﺘﺠـﺎﻭﺯ‬ ‫ﺼﻔﺤﺎﺘﻬﺎ ﺍﻻﻟﻑ ﺼﻔﺤﺔ، ﻭﺒﻌﺩ ﺸﺭﺡ ﻜل ﻨﻘﻁﺔ ﻴﻘﻭﻡ ﺍﻟﻤﺅﻟﻑ ﺒﻌﺭﺽ ﺠﺩﻭل ﻤﻨﺴﻭﺥ ﻤـﻥ ﻭﺜـﺎﻕ‬ ‫‪.NET‬‬ ‫‪ Documentation‬ﻭﺍﻀﺎﻓﺘﻪ. ﻭﻟﻜﻥ ﻤﻊ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻓﻠﻥ ﻴﺤﺩﺙ ﻤﻌﻙ ﺫﻟﻙ، ﺤﻴﺙ ﺍﻨـﻙ ﺴـﺘﻼﺤﻅ ﺠﻤﻠـﺔ‬ ‫ﺍﻟﻤﺅﻟﻑ ﺍﻟﻤﺘﻜﺭﺭﺓ "ﺭﺍﺠﻊ ﻤﻜﺘﺒﺔ ‪ MSDN‬ﻟﻤﺯﻴﺩ ﻤﻥ ﺍﻟﺘﻔﺎﺼﻴل" ﻭﻫﺫﺍ ﺨﻴﺭ ﺩﻟﻴل ﻋﻠـﻰ ﺍﻥ ﺍﻟﻜﺎﺘـﺏ ﻻ ﻴﺭﻴـﺩ‬ ‫ﺯﻴﺎﺩﺓ ﺍﻟﺼﻔﺤﺎﺕ ﺍﻟﻤﻨﺴﻭﺨﺔ ﻤﻥ ﻭﺜﺎﺌﻕ ‪ .NET Documentation‬ﻭﺘﻜﺭﺍﺭﻫﺎ ﻓﻲ ﻜﺘﺎﺒﻪ.‬ ‫ﻭﺨﺘﺎﻤﺎ ﺃﺘﻤﻨﻰ ﻤﻥ ﺍﷲ ﺃﻥ ﻴﻭﻓﻕ ﺍﻟﻤﺅﻟﻑ ﻓﻲ ﻨﺸﺭ ﺍﻟﻤﻌﺭﻓﺔ ﻟﻠﻌﺭﺏ، ﻭﺃﻥ ﻴﺒﺩﺃ ﺍﻟﺸـﺒﺎﺏ ﺒﺎﻟﻤﻀـﻲ ﻗـﺩﻤﺎ‬ ‫ﹰ‬ ‫ﹰ‬ ‫ﻓﻲ ﻤﺠﺎل ﺍﻟﻨﺸﺭ ﻭﺍﻟﺘﻌﻠﻴﻡ ﻷﻨﻪ ﺴﻼﺡ ﺍﻟﻌﺼﺭ، ﻭﺍﻨﺎ ﻭﺍﺜﻕ ﻜﺎﻤل ﺍﻟﺜﻘﺔ ﺒﺄﻨﻙ ﻟﻥ ﺘﺸﻌﺭ ﺒﺎﻟﻨﺩﻡ ﺒﻌـﺩ ﺍﻗﺘﻨﺎﺌـﻙ ﻟﻬـﺫﺍ‬ ‫ﺍﻟﻜﺘﺎﺏ، ﻭﻟﻥ ﺘﻀﻌﻪ ﻤﻊ ﺍﻟﻜﺘﺏ ﺍﻻﺨﺭﻯ ﻓﻲ ﺭﻓﻭﻑ ﻤﻜﺘﺒﺘﻙ، ﺒل ﺴﻴﻅل ﻨﺎﺼﺒﺎ ﻋﻠﻰ ﺴﻁﺢ ﻤﻜﺘﺒﻙ.‬ ‫ﺘﻨﺒﻴﻪ ﺍﺨﻴﺭ ﻨﺎﺘﺞ ﻤﻥ ﺘﺠﺭﺒﺔ ﺸﺨﺼﻴﺔ: ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﻤﻔﺎﺠﺌﺎﺕ ﻭﺍﻻﻓﻜﺎﺭ ﺴﺘﺠﺩﻫﺎ ﻓـﻲ ﻫـﺫﺍ ﺍﻟﻜﺘـﺎﺏ،‬ ‫ﻟﺫﻟﻙ ﻻ ﺘﻘﺭﺃ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻗﺒل ﻤﻭﻋﺩ ﺍﻟﻨﻭﻡ ﺒﺩﻗﺎﺌﻕ ﺤﻴﺙ ﺍﻨـﻙ ﻟـﻥ ﺘﺴـﺘﻁﻴﻊ ﺍﻟﻨـﻭﻡ ﺩﻭﻥ ﺘﺠﺭﺒـﺔ ﺍﻟﺸـﻴﻔﺭﺍﺕ‬ ‫ﺍﻟﻤﺼﺩﺭﻴﺔ ﺒﻨﻔﺴﻙ!‬ ‫ﺇﻴﺎﺩ ﻴﺤﻴﻰ ﻤﻜﻲ ﺯﻜﺭﻱ،‬ ‫ﻋﻀﻭ ﻓﻲ ﺍﻹﺘﺤﺎﺩ ﺍﻟﻌﺎﻟﻤﻲ ﻟﻤﺼﻤﻤﻲ ﻭﻤﺩﺭﺍﺀ ﺍﻟﻤﻭﻗﻊ ‪.(iawmd.com) IAWMD‬‬ ‫ﺍﻟﻤﺅﺴﺱ ﺍﻟﻤﺸﺎﺭﻙ ﻟﺸﺭﻜﺔ ﺍﻹﻨﺘﺭﻨﺕ ﻟﻠﺠﻤﻴﻊ ﺒﺎﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ‪.(ifawal.com) IFAWAL‬‬
  • 23.
    ‫ج‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫اﻟﻤﻘﺪﻣﺔ‬ ‫ﻋﻨﺩﻤﺎ ﺸﺭﻋﺕﻓﻲ ﻜﺘﺎﺒﺔ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ، ﺨﺎﻨﺘﻨﻲ ﺍﻟﻌﺒﺭﺓ ﻭﻟـﻡ ﺘـﺎﺘﻲ ﺍﻟﺘﻭﻗﻌـﺎﺕ ﻜﻤـﺎ ﺭﺴـﻤﺕ ﻓـﻲ ﺍﻟﺨـﺎﻁﺭ،‬ ‫ﻓﺎﻟﻤﻭﻀﻭﻉ ﺍﻜﺒﺭ ﻤﻥ ﻜﻭﻨﻪ ﺸﺭﺡ ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﻭﺍﺠﺭﺍﺀ ﺘﻁﺒﻴﻘﺎﺕ ﺒﻬﺎ، ﺤﻴﺙ ﺍﻥ ﻜﺘﺎﺒﺔ ﻜﺘﺎﺏ ﻋﻥ ﻟﻐـﺔ ﺍﻟﺒﺭﻤﺠـﺔ‬ ‫‪ Visual Basic .NET‬ﻟﻴﺱ ﺴﻭﻯ ﻟﻬﺠﺔ ﺒﻠﺴﺎﻥ ﺍﺨﺭ ﺘﺨﺎﻁﺏ ﺒﻬﺎ ﺘﻘﻨﻴﺔ ‪.Microsoft .NET‬‬ ‫ﺴﻭﺍﺀ ﻜﻨﺕ ﻤﺒﺭﻤﺞ ‪ Visual Basic .NET‬ﺍﻭ ﻤﺒﺭﻤﺞ ‪ Visual C# .NET‬ﺍﻭ ﺍﻱ ﻟﻐـﺔ ﺒﺭﻤﺠـﺔ‬ ‫ﺍﺨﺭﻯ ﻤﻭﺠﻬﻪ ﺍﻟﻰ ﺍﻁﺎﺭ ﻋﻤل ‪ .NET Framework‬ﻓﻠﻥ ﺘﻘﺩﻡ ﻭﻟﻥ ﺘﺎﺨﺭ ﺫﻟﻙ ﺍﻟﺸﺊ ﺍﻟﻜﺒﻴـﺭ، ﺍﺫ ﺍﻥ ﺍﻟﻠﻘـﺏ‬ ‫ﺍﻟﺫﻱ ﻋﻠﻴﻙ ﺍﻟﺒﺤﺙ ﻋﻨﻪ ﺩﺍﺌﻤﺎ ﻫﻭ ﻤﺒﺭﻤﺞ ‪ .NET‬ﺍﻭ –ﻟﻤﺯﻴـﺩ ﻤـﻥ ﺍﻟﺘﻔﺼـﻴل - ﻤﺒـﺭﻤﺞ ‪ .NET‬ﺒﻠﻬﺠـﺔ‬ ‫‪ .Visual Basic .NET‬ﻭﺍﻥ ﻟﻡ ﻴﺘﻀﺢ ﻟﻙ ﺍﻟﻤﻌﻨﻰ ﻤﻥ ﺍﻟﻠﻘﺏ ﻤﺒﺭﻤﺞ ‪ ،.NET‬ﻓﻌﻠﻴـﻙ ﻤﻌﺭﻓـﺔ ﺍﻥ ﻟﻐـﺔ‬ ‫ﺍﻟﺒﺭﻤﺠﺔ ‪ Visual Basic .NET‬ﻟﻴﺴﺕ ﺴﻭﻯ ﻤﻔﺘﺎﺡ ﺒﺴﻴﻁ ﺘﺴﺘﺨﺩﻤﻪ ﻟﻠﺒـﺎﺏ ﺍﻟﻤﻌﻘـﺩ ﻭﺍﻟﻤﺴـﻤﻰ ‪.NET‬‬ ‫‪ ،Framework‬ﻓﺎﻻﺤﺘﺭﺍﻑ ﻓﻲ ﺒﺭﻤﺠﺔ ‪ Visual Basic .NET‬ﻟﻥ ﻴﺘﻁﻠﺏ ﻤﻨﻙ ﺫﻟﻙ ﺍﻟﺠﻬﺩ ﻟﻠﻭﺼﻭل ﺍﻟﻴـﻪ‬ ‫ﻓﻲ ﺍﻴﺎﻤﺎ ﻤﻌﺩﻭﺩﺍﺕ ) ﻗﺭﺍﺀﺓ ﺍﻟﻔﺼﻭل ﺍﻟﺨﻤﺱ ﺍﻻﻭﻟﻰ ﻤﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻜﺎﻓﻴﺔ ﺍﻟﻰ ﺤﺩ ﻜﺒﻴـﺭ(، ﺍﻤـﺎ ﺍﻻﺤﺘـﺭﺍﻑ‬ ‫ﻓﻲ ﺘﻘﻨﻴﺔ ‪ .NET‬ﻓﻴﺤﺘﺎﺝ ﺍﻟﻰ ﺘﻔﺭﻍ ﺫﻫﻨﻲ ﻤﻥ ﻜل ﺸﺊ ﻓﻲ ﺤﻴﺎﺘﻙ ﺘﻘﺭﻴﺒﺎ.‬ ‫ﺍﻁﺎﺭ ﻋﻤل ‪ .NET Framework‬ﻤﻌﻘﺩ ﺠﺩﺍ، ﻭﻫﻭ ﺒﺤﺭ ﻟﻴﺱ ﻟﻪ ﺒﺩﺍﻴﺔ ﻭﻻ ﻨﻬﺎﻴﺔ، ﻭﻗـﺩ ﻻ ﺍﺒـﺎﻟﻎ ﺍﻥ‬ ‫ﻗﻠﺕ ﺍﻥ ﻜل ﻤﻴﻨﺎﺀ ﻤﻥ ﻤﻭﺍﻨﻲ ﻫﺫﺍ ﺍﻟﺒﺤﺭ ﺘﺤﺘـﺎﺝ ﺍﻟـﻰ ﻜﺘـﺎﺏ ﻤﺨﺼـﺹ. ﻓـﺂﻻﻑ ﺍﻟﺼـﻔﺤﺎﺕ ﻭﺍﻟﺨﺎﺼـﺔ‬ ‫ﺒﻤﺴﺘﻨﺩﺍﺕ ﺘﻘﻨﻴﺔ ‪ Microsoft .NET‬ﺍﻟﺭﺴﻤﻴﺔ ﺨﻴﺭ ﺩﻟﻴل. ﻭﻟﺘﻘﺩﻴﻡ ﻜﺘﺎﺏ ﻋﻥ ﻫﺫﻩ ﺍﻟﺘﻘﻨﻴﺔ، ﻜﺎﻥ ﻋﻠـﻲ ﺍﺨﺘﻴـﺎﺭ‬ ‫ﺍﺤﺩ ﺍﻟﺤﻠﻭل ﺍﻟﺜﻼﺙ:‬ ‫ﺍﻻﻭل ﻫﻭ ﻜﺘﺎﺒﺔ ﻜﺘﺏ ﻤﺘﻌﺩﺩﺓ ﻴﺨﺘﺹ ﻜل ﻭﺍﺤﺩ ﻓﻴﻬﺎ ﺒﻤﺠﺎل ﻤﻌـﻴﻥ، ﻜﺘـﺎﺏ ﻋـﻥ ﺘﻁـﻭﻴﺭ ﺘﻁﺒﻴﻘـﺎﺕ‬ ‫‪ Windows‬ﻭﺍﺨﺭ ﻋﻥ ﺒﺭﻤﺠﺔ ﻭﻴﺏ، ﻭﺜﺎﻟﺙ ﻋﻥ ﺍﻻﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﺘﻘﺩﻡ ﻟﺘﻘﻨﻴـﺔ ‪ ADO.NET‬ﻟﺒﺭﻤﺠـﺔ ﻗﻭﺍﻋـﺩ‬ ‫ﺍﻟﺒﻴﺎﻨﺎﺕ، ﻭﻟﻜﻥ ﻴﻌﻴﺒﻪ ﺍﻟﻭﻗﺕ ﺍﻟﻁﻭﻴل ﺍﻟﺫﻱ ﺴﻴﺴﺘﻐﺭﻗﻪ ﺒﺎﻻﻀﺎﻓﺔ ﺍﻟﻰ ﺍﻥ ﺠﻤﻴﻌﻬـﺎ ﺘﺘﻁﻠـﺏ ﺸـﺭﺡ ﺍﺴﺎﺴـﻴﺎﺕ‬ ‫ﺍﻟﻠﻐﺔ، ﻤﻤﺎ ﻴﻌﻨﻲ ﺘﻜﺭﺍﺭ ﻤﻌﻅﻡ ﺍﻟﺼﻔﺤﺎﺕ. ﺍﻟﺤل ﺍﻟﺜﺎﻨﻲ، ﻫﻭ ﻤﺸﺎﺭﻜﺔ ﻜﺘﺎﺏ ﺍﺨﺭﻴﻥ ﻭﻤﺤﺎﻭﻟﺔ ﺘﻭﺴـﻌﺔ ﻭﺯﻴـﺎﺩﺓ‬ ‫ﺍﻟﻤﺎﺩﺓ ﺍﻟﻌﻠﻤﻴﺔ ﻓﻲ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ، ﻭﻟﻜﻥ ﻴﻌﻴﺒﻪ ﺍﺨﺘﻼﻑ ﺍﻻﺴﺎﻟﻴﺏ ﺍﻟﺘﻲ ﻴﺘﺒﻌﻬـﺎ ﻜـل ﻤﺅﻟـﻑ ﻤﻤـﺎ ﻗـﺩ ﻴﺴـﺒﺏ‬ ‫ﺍﻟﺘﺸﻭﻴﺵ ﻋﻠﻰ ﺍﻟﻘﺎﺭﺉ. ﺍﻤﺎ ﺍﻟﺤل ﺍﻟﺜﺎﻟﺙ ﻓﻬﻭ ﺍﻗﺘﻁﺎﻑ ﻤﻥ ﻜل ﺒﺴﺘﺎﻥ ﺯﻫﺭﺓ ﻭﻭﻀﻌﻬﺎ ﻜﻤﻘﺩﻤـﺔ ﻭﻤـﺩﺨل ﻟـﻙ‬ ‫ﻴﻤﻜﻨﻙ ﻤﻥ ﺍﻻﻨﻁﻼﻕ ﻤﻨﻪ، ﻭﻫﺫﺍ ﻤﺎ ﻓﻌﻠﺘﻪ ﻓﻲ ﻜﺘﺎﺏ ﺒﺭﻤﺠـﺔ ﺍﻁـﺎﺭ ﻋﻤـل ‪ .NET‬ﺒﺎﺴـﺘﺨﺩﺍﻡ ‪Visual‬‬ ‫‪.Basic .NET‬‬ ‫ﻟﻤﻦ هﺬا اﻟﻜﺘﺎب؟‬ ‫ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻟﻠﻤﺒﺘﺩﺌﻴﻥ ﺍﻡ ﻟﻠﻤﺘﻭﺴﻁﻴﻥ ﺍﻭ ﻟﻠﻤﺤﺘﺭﻓﻴﻥ؟ ﺴﺅﺍل ﻴﺭﺍﻭﺩ ﺍﻏﻠﺏ ﺍﻟﻤﺒـﺭﻤﺠﻴﻥ، ﻭﻴﻬﺘﻤـﻭﻥ ﻓـﻲ ﺍﺠﺎﺒﺘـﻪ‬ ‫ﺍﻜﺜﺭ ﻤﻥ ﺍﻫﺘﻤﺎﻤﻬﻡ ﺒﻤﺅﻟﻑ ﺍﻟﻜﺘﺎﺏ. ﻟﻜل ﺍﻨﺴﺎﻥ ﻤﻘﻴﺎﺱ ﺨﺎﺹ ﻟﺘﺼﻨﻴﻑ ﺍﻟﻤﺴـﺘﻭﻴﺎﺕ، ﻭﻗـﺩ ﻴﻜـﻭﻥ ﻤﻘﻴﺎﺴـﻲ‬ ‫ﺍﻟﺸﺨﺼﻲ ﻤﺭﻓﻭﺽ ﻤﻥ ﻗﺒل ﺍﻟﻜﺜﻴﺭﻴﻥ، ﻟﺫﻟﻙ ﻟﻥ ﺍﻋﻁﻴﻙ ﺍﺠﺎﺒﺔ ﻤﺒﺎﺸﺭﺓ ﻟﻬﺫﺍ ﺍﻟﺴﺅﺍل، ﻭﺴﺄﻜﺘﻔﻲ ﺒـﺫﻜﺭ ﺼـﻔﺎﺕ‬ ‫ﺍﻻﺸﺨﺎﺹ ﺍﻟﺫﻴﻥ ﺍﻋﺘﻘﺩ ﺍﻥ ﺍﻟﻜﺘﺎﺏ ﺴﻴﻜﻭﻥ ﻤﻨﺎﺴﺏ ﻟﻪ ﻤﻥ ﻨﻅﺭﺘﻲ ﺍﻟﺸﺨﺼﻴﺔ.‬
  • 24.
    ‫د‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺍﺴﺘﻁﻴﻊ ﺘﺼﻨﻴﻑﻜﺘﺏ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻰ ﺍﺭﺒﻊ ﺍﻨـﻭﺍﻉ، ﺍﻟﻨـﻭﻉ ﺍﻻﻭل ﻭﻫـﻭ ﺍﻟﺘﻌﻠﻴﻤـﻲ ‪Tutorial‬‬ ‫ﺤﻴﺙ ﻴﻭﺠﻪ ﺍﻟﻰ ﺍﻻﺸﺨﺎﺹ ﺍﻟﺫﻴﻥ ﻟﻴﺱ ﻟﺩﻴﻬﻡ ﺍﻟﻭﻗﺕ ﺍﻟﻜﺎﻓﻲ ﻟﻠﻘﺭﺍﺀﺓ، ﻭﻻ ﻴﻭﺩﻭﻥ ﺍﺴﺘﻴﻌﺎﺏ ﺍﻟﻤﺒـﺎﺩﺉ ﺒﻘـﺩﺭ ﻤـﺎ‬ ‫ﻴﻬﻤﻬﻡ ﺍﻨﺠﺎﺯﻫﺎ. ﻓﺴﺘﺠﺩ ﻓﻲ ﻤﺜل ﻫﺫﻩ ﺍﻟﻨﻭﻋﻴﺔ ﻤﻥ ﺍﻟﻜﺘﺏ ﻋﺸﺭﺍﺕ ﺍﻟﺴﻁﻭﺭ ﺍﻟﻤﺘﻤﺜل ﻓﻲ ﺨﻁـﻭﺍﺕ ‪Step by‬‬ ‫‪ Step‬ﻤﺭﻗﻤﺔ ﺘﻘﻭﻡ ﺒﺎﻨﺠﺎﺯ ﻤﻬﻤﺔ ﻤﻌﻴﻨﺔ ﺩﻭﻥ ﺫﻟﻙ ﺍﻟﺸﺭﺡ.‬ ‫ﺍﻟﻨﻭﻉ ﺍﻟﺜﺎﻨﻲ ﻫﻭ ﺍﻟﻤﺭﺍﺠﻊ ‪ ،Reference‬ﻭﻫﻲ ﻜﺘﺏ ﻻ ﺘﻘﺭﺃ ﻤﻥ ﺍﻟﻐﻼﻑ ﺍﻟﻰ ﺍﻟﻐﻼﻑ ﻭﺍﻨﻤـﺎ ﻴﺭﺠـﻊ‬ ‫ﻟﻬﺎ ﻤﻥ ﻭﻗﺕ ﻻﺨﺭ. ﻭﻜﻤﺎ ﺘﻌﻠﻡ ﺍﻥ ﺍﻟﻤﺭﺍﺠﻊ ﺘﻜﺘﺏ ﻤﻥ ﻗﺒل ﺍﻻﻑ ﺍﻻﺸﺨﺎﺹ، ﻭﻗـﺩ ﺍﺤﺘـﺎﺝ ﻟﻠﻜﺘﺎﺒـﺔ ﺒﺎﺼـﺎﺒﻊ‬ ‫ﻗﺩﻤﻲ ﺤﺘﻰ ﺍﻨﺠﺯ ﻤﺭﺠﻊ ﻗﺒل ﺍﻥ ﺘﺸﻴﺏ ﺸﻌﺭﺍﺕ ﺭﺃﺴﻲ.‬ ‫ﺍﻟﻨﻭﻉ ﺍﻟﺜﺎﻟﺙ ﻤﻥ ﺍﻨﻭﺍﻉ ﺍﻟﻜﺘﺏ ﻫﻭ ﻭﺭﺸﺔ ﺍﻟﻌﻠﻡ ‪ ،Workshop‬ﻭﻫـﻭ ﻋﻨـﺩﻤﺎ ﻴﻤﻴـل ﺍﻟﻜﺘـﺎﺏ ﺍﻟـﻰ‬ ‫ﺍﻟﺠﺎﻨﺏ ﺍﻟﺘﻁﺒﻴﻘﻲ ﺍﻜﺜﺭ ﻤﻥ ﺍﻟﺸﺭﺡ، ﻭﻟﻜﻥ ﻴﻔﺘﺭﺽ ﺍﻟﻤﺅﻟﻑ ﺍﻨﻙ ﺘﻌﻠﻡ ﻜل ﺸﺊ ﻋـﻥ ﻟﻐـﺔ ﺍﻟﺒﺭﻤﺠـﺔ، ﺤﻴـﺙ‬ ‫ﻴﻌﺭﺽ ﻟﻙ ﺍﻻﺴﺎﻟﻴﺏ ﺍﻟﺒﺭﻤﺠﻴﺔ ﺍﻟﻤﺘﻌﺩﺩﺓ ﻻﻨﺠﺎﺯ ﺍﻟﻤﻬﺎﻡ ﻭﺘﻁﺒﻴﻘﻬﺎ ﻤﺒﺎﺸﺭﺓ.‬ ‫ﺍﻤﺎ ﺍﻟﻜﺘﺎﺏ ﺍﻟﺫﻱ ﺍﻤﺎﻡ ﻋﻴﻨﻴﻙ ﻓﻬﻭ ﻤﻥ ﺍﻟﻨﻭﻉ ﺍﻟﺭﺍﺒﻊ ﻭ ﻫـﻭ ﺍﻻﺴـﺘﻴﻌﺎﺒﻲ ‪ Comprehensive‬ﻓﺄﻤﻴـل‬ ‫ﻓﻴﻪ ﺍﻟﻰ ﺸﺭﺡ ﺍﻻﺴﺎﺴﻴﺎﺕ ﻭﺒﻨﺎﺀ ﻗﻭﺍﻋﺩ ﻤﻌﺭﻓﻴﺔ ﻟﺘﺘﻤﻜﻥ ﻤﻥ ﺍﻻﻨﻁﻼﻕ ﻓـﻲ ﺒﺭﻤﺠـﺔ ﺍﻁـﺎﺭ ﻋﻤـل‬ ‫‪.NET‬‬ ‫‪ Framework‬ﻤﻥ ﺍﻭﺴﻊ ﺍﺒﻭﺍﺒﻬﺎ، ﺤﻴﺙ ﻴﻤﻜﻨﻙ ﺍﻋﺘﺒﺎﺭ ﺍﻥ ﻜل ﻓﺼل ﻤﻥ ﻓﺼـﻭل ﻫـﺫﺍ ﺍﻟﻜﺘـﺎﺏ ﻤﻘﺩﻤـﺔ ﺍﻭ‬ ‫ﻤﺩﺨل ﺍﻟﻰ ﺍﺴﺘﺨﺩﺍﻡ ﺘﻘﻨﻴﺔ ﻤﻥ ﺘﻘﻨﻴﺎﺕ ﺍﻁﺎﺭ ﻋﻤل ‪ ،.NET Framework‬ﻭﻴﺒﻘﻰ ﺍﻻﻤﺭ ﻓـﻲ ﺍﻟﻨﻬﺎﻴـﺔ ﻋﻠﻴـﻙ‬ ‫ﻟﺘﺘﻌﻤﻕ ﻭﺘﺘﺨﺼﺹ ﻓﻲ ﺍﻟﻤﺠﺎل ﺍﻟﺫﻱ ﺘﺭﻴﺩﻩ ﺒﻨﻔﺴﻙ.‬ ‫ﻣﺎذا ﻋﻦ ﻣﺒﺮﻣﺠﻲ 6‪Visual Basic 1Î‬؟‬ ‫ﺤﺴﻨﺎ، ﺩﻋﻨﻲ ﻫﻨﺎ ﺍﺨﺎﻁﺏ ﺘﻠﻙ ﺍﻟﻔﺌﺔ ﻤﻥ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﻋﺸﺎﻕ ﺍﻟﻨﻐﻤﺔ ﺍﻟﺭﻨﺎﻨـﺔ ‪ .Visual Basic‬ﺍﻟﻌﻼﻗـﺔ ﺒـﻴﻥ‬ ‫‪ Visual Basic .NET‬ﻭ ﺍﻻﺼﺩﺍﺭﺍﺕ ﺍﻟﺴﺎﺒﻘﺔ 6>-1 ‪ Visual Basic‬ﻻ ﺘﻜﺎﺩ ﺍﻥ ﺘﻜﻭﻥ ﺍﻻ ﻋﻼﻗﺔ ﺘﺸـﺎﺒﻪ‬ ‫ﺍﺴﻤﺎﺀ، ﻓﻬﻲ ﻤﺸﺭﻭﻉ ﺘﺴﻭﻴﻘﻲ ﺍﻜﺜـﺭ ﻤﻥ ﻤـﺎ ﻫـﻭ ﺘﻁـﻭﻴﺭ ﻟﻠﻐـﺔ ﺍﻟﺒﺭﻤﺠـﺔ ﺍﻟﻤﺤﺘﻜــﺭﺓ ﻤــﻥ ﻗﺒـل‬ ‫‪ .Microsoft‬ﺤﻴﺙ ﺍﻥ ﺍﻟﻀﺭﻴﺒﺔ ﺍﻟﺘﻲ ﻜﺎﻨﺕ ﺴﺘﻜﻠﻑ ﻤﺸﺭﻭﻉ ‪ Microsoft .NET‬ﻫﻭ ﺍﻨﺘﺎﺝ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠـﺔ‬ ‫ﺍﻟﺠﺩﻴﺩﺓ ‪ Visual C# .NET‬ﻭﺍﻻﺴﺘﻐﻨﺎﺀ ﻋﻥ ﺍﻟﻤﻼﻴﻴﻥ ﻤﻥ ﻤﺒﺭﻤﺠﻲ ‪ .Visual Basic‬ﺍﻨﺘﺎﺝ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠـﺔ‬ ‫ﺍﻟﺠﺩﻴﺩﺓ ﺍﻤﺭ ﻻ ﺒﺄﺱ ﻤﻨﻪ، ﺍﻤﺎ ﻗﻀﻴﺔ ﺍﻻﺴﺘﻐﻨﺎﺀ ﻋﻥ ﻤﻼﻴﻴﻥ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﻓﻬﻲ ﺒﺤﺎﺠﺔ –ﺒﻜل ﺘﺄﻜﻴﺩ - ﺍﻟـﻰ ﺍﻋـﺎﺩﺓ‬ ‫ﻨﻅﺭ.‬ ‫ﺒﻭﻀﻭﺡ ﻭﺼﺭﺍﺤﺔ ﻤﺒﺎﺸﺭﺓ، ﺍﻨﺘﺠـﺕ ‪ Microsoft‬ﻟﻐـﺔ ﺍﻟﺒﺭﻤﺠـﺔ ﺍﻟﺠﺩﻴـﺩﺓ ‪Visual C# .NET‬‬ ‫ﻭﺍﻜﺎﺩ ﺍﺘﺨﻴل ﺍﺤﺩ ﺼﻨﺎﻉ ﺍﻟﻘﺭﺍﺭ ﻓﻲ ﺘﻠﻙ ﺍﻟﺸﺭﻜﺔ ﻴﻘﻭل: ﻟﻤﺎ ﻻ ﻨﻘﻭﻡ ﺒﺎﺴـﺘﺒﺩﺍل ﺼـﻴﻎ ﻟﻐـﺔ #‪ C‬ﺍﻟـﻰ ﺼـﻴﻎ‬ ‫ﺸﺒﻴﻬﻪ ﺒﻠﻐﺔ ‪ ،BASIC‬ﺍﻱ –ﺒﺎﺨﺘﺼﺎﺭ - ﺍﺤﺫﻓﻭﺍ ﺍﻻﻗﻭﺍﺱ ﻤﻥ ﻋﺒـﺎﺭﺓ ﺍﻟﺸـﺭﻁ ‪ if‬ﻭﺍﺠﺒـﺭﻭﺍ ﻜﺘﺎﺒـﺔ ‪Then‬‬ ‫ﺒﻌﺩﻫﺎ، ﻤﻊ ﺍﻟﻐﺎﺀ ﻀﺭﻭﺭﺓ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻔﺎﺼﻠﺔ ﺍﻟﻤﻨﻘﻭﻁﺔ ";" ﻨﻬﺎﻴﺔ ﻜل ﺴﻁﺭ.‬ ‫ﺼﺤﻴﺢ ﺍﻥ ‪ Visual Basic .NET‬ﻫﻲ ﻨﺴﺨﺔ ﺒﻠﺴـﺎﻥ ﺍﺨـﺭ ﻤـﻥ ‪ ،Visual C# .NET‬ﺍﻻ ﺍﻥ‬ ‫ﺍﻟﻔﺭﻭﻕ ﻁﻔﻴﻔﺔ ﻭﻻ ﺘﻜﺎﺩ ﺘﺫﻜﺭ )ﺍﺴﺘﻁﻴﻊ ﺍﻥ ﺍﺠﺯﻡ ﺍﻥ ‪ Microsoft‬ﺘﻌﻤﺩﺕ ﻭﻀﻊ ﻫﺫﻩ ﺍﻟﻔـﺭﻭﻕ ﺤﺘـﻰ ﻨﻘﺘﻨـﻊ‬ ‫ﺍﻨﻬﻤﺎ ﻟﻐﺘﺎ ﺒﺭﻤﺠﺔ ﻤﺨﺘﻠﻔﺘﻴﻥ(.‬ ‫ﺒﺎﻟﺭﻏﻡ ﻤﻥ ﺘﺸﺎﺒﻪ ﺍﻟﺼﻴﻎ ﺒﻴﻥ ‪ Visual Basic .NET‬ﻭﺍﻻﺼـﺩﺍﺭﺍﺕ ﺍﻟﺴـﺎﺒﻘﺔ -1 ‪Visual Basic‬‬ ‫6> ﺍﻻ ﺍﻨﻪ ﻤﻥ ﺍﻟﺨﻁﺄ ﺍﻟﻜﺒﻴﺭ ﻭﺍﻟﺠﺭﻡ ﺍﻟﻌﻅﻴﻡ ﺍﻋﺘﺒﺎﺭ ‪ Visual Basic .NET‬ﺍﺼﺩﺍﺭ ﺠﺩﻴـﺩ ﻤﻨﻬـﺎ، ﺤﻴـﺙ‬
  • 25.
    ‫ﻩ‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺍﻨﻙ ﺴﺘﺘﻌﺎﻤلﻤﻊ ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﺠﺩﻴﺩﺓ ﻜﻠﻴﺎ ﻭﻟﻴﺱ ﻟﻬﺎ ﺍﻱ ﻋﻼﻗﺔ –ﻜﻤﺎ ﺫﻜﺭﺕ - ﻤﻊ ﺍﻻﺼـﺩﺍﺭﺍﺕ ﺍﻟﺴـﺎﺒﻘﺔ ﻤـﻥ‬ ‫‪ .Visual Basic‬ﻟﺫﻟﻙ، ﺘﻘﺒل ﻨﺼﻴﺤﺘﻲ ﻫﺫﻩ ﻗﺒل ﺍﻥ ﺘﻌﺎﻨﻲ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﻤﺘﺎﻋﺏ –ﻜﻤﺎ ﻋﺎﻨﻴـﺕ ﺍﻨـﺎ - ﻭﺍﻨﺴـﻰ‬ ‫ﻜل ﻤﺎ ﺘﻌﻠﻤﺘﻪ ﺴﺎﺒﻘﺎ ﻓﻲ ﺍﻻﺼﺩﺍﺭﺍﺕ ﺍﻟﻘﺩﻴﻤﺔ ﻤﻥ ‪ ،Visual Basic‬ﻭﻀﻊ ﻓﻲ ﻋـﻴﻥ ﺍﻋﺘﺒـﺎﺭﻙ ﺩﺍﺌﻤـﺎ ﺍﻨـﻙ‬ ‫ﺘﺘﻌﺎﻤل ﻤﻊ ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﺠﺩﻴﺩﺓ ﻭﺤﺩﻴﺜﺔ ﺍﻟﻌﻬﺩ ﺍﺴﻤﻬﺎ ‪.Microsoft Visual Basic .NET‬‬ ‫اﻟﻤﺼﻄﻠﺤﺎت ﺗﻌﺮﻳﺐ ام ﺗﻌﺬﻳﺐ؟‬ ‫ﻻﺘﺯﺍل ﻤﺸﻜﻠﺔ ﺍﻟﻤﺼﻁﻠﺤﺎﺕ ﺍﻟﻌﺭﺒﻴﺔ ﻓﻲ ﺭﻤﺘﻬﺎ، ﻭﺒﻤﺎ ﺍﻨﻨﻲ ﻟﺴﺕ ﻓـﻲ ﻤﻨﺼـﺏ ﻤﺴـﺅﻭل ﻟﺘﺤﺩﻴـﺩ ﻭﺍﺨﺘﻴـﺎﺭ‬ ‫ﺍﻟﺘﺭﺠﻤﺎﺕ ﺍﻟﻌﺭﺒﻴﺔ ﺍﻟﺼﺤﻴﺤﺔ ﻟﻠﻤﺼﻁﻠﺤﺎﺕ ﺍﻻﺠﻨﺒﻴﺔ، ﻓﺫﻟﻙ ﻴﻌﻨـﻲ ﺤﺭﻴﺘـﻲ ﻓـﻲ ﺍﺨﺘﻴـﺎﺭ ﻤـﺎ ﺍﺭﺍﻩ ﻤﻨﺎﺴـﺒﺎ‬ ‫ﻭﺭﻓﺽ ﻤﺎ ﻻ ﻴﻨﺎﺴﺒﻨﻲ.‬ ‫ﻭﺠﻬﺔ ﻨﻅﺭﻱ ﺍﻟﺸﺨﺼﻴﺔ ﺤﻭل ﺘﺭﺠﻤﺔ ﺍﻟﻤﺼﻁﻠﺤﺎﺕ ﺘﺘﻤﺤﻭﺭ ﺤﻭل ﺍﺨﺘﻴﺎﺭ ﺍﻟﻜﻠﻤـﺔ ﺍﻻﻜﺜـﺭ ﺸـﻌﺒﻴﺔ ﺃﻭ‬ ‫ﺍﻟﺘﻲ ﺘﻤﻴل ﺍﻟﻰ ﺘﻭﻀﻴﺢ ﺍﻟﻤﻌﻨﻰ ﺍﻟﺘﻘﻨﻲ ﻭﻟﻴﺱ ﺍﻟﻤﻌﻨﻰ ﺍﻟﺤﺭﻓﻲ، ﻟﺩﻴﻙ ﺍﻟﻜﻠﻤﺔ ‪ Help‬ﻤـﺜﻼ ﻭﺍﻟﺘـﻲ ﺘﺘـﺭﺠﻡ –‬ ‫ﺒﺸﻜل ﺼﺤﻴﺢ - ﺍﻟﻰ "ﻤﺴﺎﻋﺩﺓ"، ﻭﻟﻜﻨﻲ ﻓﻀﻠﺕ ﺍﺨﺘﻴﺎﺭ ﺍﻟﻤﺼﻁﻠﺢ "ﺘﻌﻠﻴﻤﺎﺕ" ﻟﺸـﻌﺒﻴﺘﻪ ﺒـﻴﻥ ﻤﺴـﺘﺨﺩﻤﻲ ﻨﻅـﻡ‬ ‫‪ .Windows‬ﻤﻥ ﻨﺎﺤﻴﺔ ﺍﺨﺭﻯ، ﻟﺩﻴﻙ ﺍﻟﻤﺼﻁﻠﺢ ‪ Overloading‬ﻭﺍﻟﺫﻱ ﺘﺘﺭﺠﻤﻪ ﺍﻟﻜﺘﺏ ﺍﻟﻌﺭﺒﻴـﺔ "ﺒﺎﻟﺘﺤﻤﻴـل‬ ‫ﺍﻟﺯﺍﺌﺩ"، ﻭﻫﻭ ﺘﻌﺒﻴﺭ ﻟﻡ ﺍﺴﺘﻁﻊ ﺘﻘﺒﻠﻪ ﻻﻤﻥ ﺒﻌﻴﺩ ﻭﻻ ﻤﻥ ﻗﺭﻴﺏ، ﻓـﻼ ﻴـﻭﺤﻲ ﻤﻌﻨـﺎﻩ ﺒﺎﻟﻬـﺩﻑ ﻤﻨـﻪ، ﻭﻜـﺎﻥ‬ ‫ﺍﺨﺘﻴﺎﺭﻱ ﻟﻠﺘﻌﺒﻴﺭ "ﺍﻋﺎﺩﺓ ﺍﻟﺘﻌﺭﻴﻑ" ﻫﻭ ﺍﻻﻨﺴﺏ ﻭﺍﻻﻓﻀل ﻟﻠﺘﺭﺠﻤﺔ ﺍﻟﺘﻘﻨﻴﺔ ﻟﻪ.‬ ‫ﻤﻊ ﺫﻟﻙ، ﻗﺩﻤﺕ ﺍﻻﻤﺭ ﻓﻲ ﺍﻟﺒﺩﺍﻴﺔ ﻭﺍﻟﻨﻬﺎﻴﺔ ﻟﻙ ﺍﻴﻬﺎ ﺍﻟﻘﺎﺭﺉ ﺍﻟﻌﺯﻴﺯ ﻻﺨﺘﻴﺎﺭ ﺍﻟﻤﺼﻁﻠﺤﺎﺕ ﺍﻟﺘﻲ ﺘﻨﺎﺴـﺏ‬ ‫ﺘﻭﺠﻬﺎﺘﻙ ﺍﻟﻠﻐﻭﻴﺔ، ﻓﻼ ﺍﻜﺎﺩ ﺍﺫﻜﺭ ﻤﺼﻁﻠﺢ ﺍﻻ ﻭﺍﺭﻓـﻕ ﺍﻟﻤﻘﺎﺒـل ﺍﻻﻨﺠﻠﻴـﺯﻱ ﻟـﻪ ﻤـﻥ ﻤﺴـﺘﻨﺩﺍﺕ ‪.NET‬‬ ‫‪ ،Documentation‬ﻭﺍﻥ ﻜﺎﻨﺕ ﺍﺨﺘﻴﺎﺭﺍﺘﻲ ﻻ ﺘﻨﺎﺴﺏ ﺘﻭﺠﻬﺎﺘﻙ ﺍﻟﻠﻐﻭﻴـﺔ، ﻓـﻴﻤﻜﻥ ﺍﻟﺸـﻁﺏ ﻋﻠـﻰ ﺍﻟﻜﻠﻤـﺔ‬ ‫ﻭﻜﺘﺎﺒﺔ ﻤﺎ ﺘﺭﻴﺩ ﺒﺩﺍﻟﻬﺎ.‬ ‫ﻣﺎذا ﻳﻘﺪم ﻟﻚ هﺬا اﻟﻜﺘﺎب؟‬ ‫ﺩﻋﻨﺎ ﻨﻀﻊ ﺍﻟﻨﻘﺎﻁ ﻋﻠﻰ ﺍﻟﺤﺭﻭﻑ، ﻭﻨﻜﻭﻥ ﻭﺍﻗﻌﻴﻥ ﻗﺩﺭ ﺍﻻﻤﻜﺎﻥ، ﻓﻘﺒل ﺍﻥ ﺘﻭﺠﻪ ﻟﻲ ﺍﻟﻨﻘﺩ ﺤﻭل ﻗﺼـﻭﺭﻱ ﻓـﻲ‬ ‫ﺫﻜﺭ ﻤﺤﺘﻭﻴﺎﺕ ﺍﻁﺎﺭ ﻋﻤل ‪ ،.NET Framework‬ﻋﻠﻴﻙ ﻤﻌﺭﻓﺔ ﺍﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻟﻴﺱ ﻤﺭﺠﻌﺎ ﻤـﻥ ﻤﺭﺍﺠـﻊ‬ ‫‪ ،MSDN‬ﻓﻼ ﺘﺘﻭﻗﻊ ﻤﻨﻲ ﺸﺭﺡ ﻜل ﺸﺊ ﻭﺫﻜﺭ ﻜﺎﻓﺔ ﺍﻟﺘﻔﺎﺼﻴل ﻋﻥ ﺍﻟﻤﻭﺍﻀﻴﻊ ﺍﻟﺘﻲ ﺘﻁﺭﻗـﺕ ﻟﻬـﺎ، ﻓﺎﻨـﻙ‬ ‫ﺘﺨﺎﻁﺏ ﺸﺨﺹ ﻴﻜﺘﺏ ﺒﻌﺸﺭﺓ ﺍﺼﺎﺒﻊ ﻓﻘﻁ، ﻭﻤﻥ ﻏﻴﺭ ﻤﻨﻁﻘﻲ ﻤﻘﺎﺭﻨﺔ ﻤﺠﻬﻭﺩﻩ ﺒﻤﺠﻬﻭﺩ ﺍﻻﻑ ﺍﻟﻤﻭﻅﻔﻴﻥ ﻓـﻲ‬ ‫ﺸﺭﻜﺔ ‪ .Microsoft‬ﻭﺍﻥ ﻜﻨﺕ ﺸﺨﺹ ﺘﻘﺩﺭ ﺍﻟﻜﻡ ﺍﻟﻌﺩﺩﻱ ﻋﻠﻰ ﺍﻟﻜﻴﻑ ﺍﻟﻤﻌﻠﻭﻤﺎﺘﻲ، ﻓﻴﺅﺴﻔﻨﻲ ﺍﺨﺒـﺎﺭﻙ ﺒـﺎﻥ‬ ‫ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻟﻴﺱ ﻤﻨﺎﺴﺏ ﻟﻙ.‬ ‫ﺍﺫﺍ ﻫل ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﺒﻬﺫﺍ ﺍﻟﺴﻭﺀ؟ ﻓﻲ ﺍﻟﺤﻘﻴﻘﺔ ﺴﺘﻜﻭﻥ ﺸﻬﺎﺩﺘﻲ –ﺒﻜل ﺘﺎﻜﻴـﺩ - ﻤﺠﺭﻭﺤـﺔ ﺍﻥ ﻤﺩﺤﺘـﻪ،‬ ‫ﹰ‬ ‫ﻭﻟﻜﻥ ﺩﻋﻨﻲ ﺍﻋﺭﺽ ﻟﻙ ﻤﺎﺫﺍ ﺴﺘﺠﺩ ﺒﻴﻥ ﺜﻨﺎﻴﺎ ﺍﻟـ 055 ﺼﻔﺤﺔ ﻭﺍﻟﻤﻜﻭﻨﺔ ﻟﻬﺫﺍ ﺍﻟﻜﺘﺎﺏ:‬ ‫ﺍﺴﺎﺴﻴﺎﺕ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ‪ Visual Basic .NET‬ﻤﻥ ﺍﻟﺼﻔﺭ ﺘﺒﺩﺃ ﺒﻌﺭﺽ ﻜﻴﻔﻴﺔ ﻜﺘﺎﺒﺔ ﺍﻭل ﺒﺭﻨـﺎﻤﺞ‬ ‫ﻟﻙ، ﻤﻊ ﺸﺭﺡ ﺍﻟﺼﻴﻎ ﻭﺍﻟﻌﺒﺎﺭﺍﺕ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻓﻲ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ﻜﺠﻤل ﺍﻟﺸﺭﻁ، ﺍﻟﺘﻔﺭﻉ، ﻭﺍﻟﺘﻜﺭﺍﺭ. ﺒﺎﻻﻀـﺎﻓﺔ‬ ‫ﺍﻟﻰ ﻨﻅﺭﺓ ﻜﺎﺌﻨﻴـﺔ ﺍﻟﺘﻭﺠـﻪ ‪ OOP‬ﻭﻁﺭﻴﻘـﺔ ﺘﻌﺭﻴـﻑ ﺍﻟﻔﺌـﺎﺕ ‪ Classes‬ﻻﻨﺸـﺎﺀ ﺍﻟﻜﺎﺌﻨـﺎﺕ ‪،Objects‬‬ ‫ﻭﺍﻻﺴﺘﺨﺩﺍﻡ ﺍﻻﻤﺜل ﻟﻬﺎ ﻟﺘﻁﺒﻴﻕ ﻤﺒﺎﺩﺉ ﺍﻟﻭﺭﺍﺜﺔ ‪ Inheritance‬ﻭﺘﻌﺩﺩ ﺍﻟﻭﺍﺠﻬﺎﺕ ‪.Polymorphism‬‬
  • 26.
    ‫و‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻋﺭﺽ ﺴﺭﻴﻊﻟﻤﻜﺘﺒﺔ ﻓﺌﺎﺕ ﺍﻁﺎﺭ ﻋﻤل ‪ .NET Framework‬ﺍﻥ ﺍﺭﺩﺕ ﺍﺨﺫ ﺠﻭﻟﺔ ﺴﺭﻴﻌﺔ ﺤـﻭل‬ ‫ﻤﻜﺘﺒﺔ ﻓﺌﺎﺕ ﺍﻁﺎﺭ ﻋﻤل ‪ ،.NET Framework‬ﻓﺴﺘﺠﺩ ﻤﻠﺨﺼﺎ ﻟﻬﺎ ﻫﻨﺎ، ﺤﻴﺙ ﺍﻋﺭﺽ ﻟﻙ ﻤﺠﻤﻭﻋـﺔ ﻤـﻥ‬ ‫ﺍﻟﻔﺌﺎﺕ ﺍﻻﺴﺎﺴﻴﺔ، ﻭﻓﺌﺎﺕ ﺍﺨﺭﻯ ﺘﺴﺘﺨﺩﻤﻬﺎ ﻻﻨﺠﺎﺯ ﻤﻬﺎﻡ ﻤﻌﻴﻨﺔ: ﻜﺎﺌﻨـﺎﺕ ﺍﻻﺴـﺘﺜﻨﺎﺀﺍﺕ ‪ ،Exceptions‬ﺩﺨـل‬ ‫ﺨﺭﺝ ﺍﻟﻤﻠﻔﺎﺕ ‪ ،File IO‬ﺘﺴﻠﺴل ﺍﻟﻜﺎﺌﻨـﺎﺕ ‪ ،Object Serialization‬ﻤﺴـﺎﺭﺍﺕ ﺍﻟﺘﻨﻔﻴـﺫ ‪،Threading‬‬ ‫ﻁﺭﻴﻘﺔ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻤﺠﻤﻌﺎﺕ ‪ Assemblies‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﻓﺌﺎﺕ ﺍﻻﻨﻌﻜﺎﺱ ‪.Reflection Classes‬‬ ‫ﺍﺴﺎﺴﻴﺎﺕ ﺘﻁﻭﻴﺭ ﺘﻁﺒﻴﻘﺎﺕ ‪ Windows Application‬ﺒﺎﺴﺘﻴﻌﺎﺏ ﻓﻜـﺭﺓ ﻨﻤـﺎﺫﺝ ‪Windows‬‬ ‫‪ Forms‬ﻭﻁﺭﻴﻘﺔ ﻭﺭﺍﺜﺘﻬﺎ، ﻜﻤﺎ ﺍﺨﺫﻙ ﻓﻲ ﺠﻭﻟﺔ ﺴﺭﻴﻌﺔ ﺤﻭل ﻤﻌﻅﻡ ﺍﻻﺩﻭﺍﺕ ‪ Controls‬ﻭﺍﻟﻐﺭﺽ ﻤﻨﻬـﺎ،‬ ‫ﺒﺎﻻﻀﺎﻓﺔ ﺍﻟﻰ ﺘﻁﺒﻴﻕ ﺘﻘﻨﻴﺔ ﺍﻟﻤﺭﺁﺓ ‪ Mirroring‬ﻋﻠﻴﻬﺎ. ﺜﻡ ﺍﺨﺼـﺹ ﻓﺼـل ﻜﺎﻤـل ﻴﻌﺘﺒـﺭ ﻤـﺩﺨﻠﻙ ﺍﻟـﻰ‬ ‫ﺍﺴﺘﺨﺩﺍﻡ ﺘﻘﻨﻴﺔ +‪ GDI‬ﻭﻁﺭﻴﻘﺔ ﺍﻟﺭﺴﻡ ﻭﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺼﻭﺭ ﻭﺍﻟﻤﺨﺭﺠﺎﺕ ﺍﻟﻨﺼﻴﺔ. ﺍﻟﻤﺯﻴـﺩ ﺍﻴﻀـﺎ، ﺍﻋـﺭﺽ‬ ‫ﻟﻙ ﻁﺭﻴﻘﺔ ﺘﻜﻭﻴﻥ ﺍﺩﻭﺍﺓ ﺨﺎﺼﺔ ‪ Custom Controls‬ﻭﺒﻨﺎﺀ ﺨﺩﻤﺎﺕ ‪.Windows Services‬‬ ‫ﺍﺴﺘﺨﺩﺍﻡ ‪ ADO.NET‬ﻟﺒﺭﻤﺠﺔ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﺸﺭﺡ ﻟﻔﻜﺭﺓ ﺍﻟﻭﻀـﻊ ﺍﻟﻤﺘﺼـل‬ ‫‪Connected‬‬ ‫‪ Mode‬ﻭﺍﻟﻭﻀﻊ ﺍﻟﻤﻨﻔﺼل ‪ ،Disconnected Mode‬ﻭﺫﻟﻙ ﺒﺫﻜﺭ ﺍﻟﻔﺌﺎﺕ ﺍﻟـﻼﺯﻡ ﺍﺴـﺘﺨﺩﺍﻤﻬﺎ ﻓـﻲ ﻜـﻼ‬ ‫ﺍﻟﻭﻀﻌﻴﻥ، ﻜﻤﺎ ﺍﺘﺤﺩﺙ ﻋﻥ ﻁﺭﻴﻘﺔ ﺭﺒﻁﻬﺎ ﺒﺎﻻﺩﻭﺍﺕ ﻭﺘﻜﺎﻤل ﺘﻘﻨﻴﺔ ‪ ADO.NET‬ﻤﻊ ‪.XML‬‬ ‫ﻤﻘﺩﻤﺔ ﻟﺒﺭﻤﺠﺔ ‪ ASP.NET‬ﻻﻋﺭﺽ ﻓﻴﻪ ﻓﻠﺴﻠﻔﺔ ﻋﻤـل ﺼـﻔﺤﺎﺕ ﺍﻟﺨـﺎﺩﻡ ‪ ASP.NET‬ﻭﺒﻨـﺎﺀ‬ ‫ﻤﻭﺍﻗﻌﻙ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻟﻬﺫﻩ ﺍﻟﺘﻘﻨﻴﺔ، ﻜﻤﺎ ﺍﻋﺭﺽ ﻟﻙ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﻜﺎﺌﻨﺎﺕ ﺍﻟﺘـﻲ ﻻ ﻏﻨـﻰ ﻋﻨﻬـﺎ ﻓـﻲ ﺍﻏﻠـﺏ‬ ‫ﻤﺸﺎﺭﻴﻊ ‪ ،ASP.NET‬ﻭﺍﺨﺘﻡ ﺍﻟﻜﺘﺎﺏ ﺒﺎﻟﺘﺤﺩﺙ ﻋﻥ ﺨـﺩﻤﺎﺕ ﻭﻴـﺏ ‪ Web Services‬ﻭﻁﺭﻴﻘـﺔ ﺍﻨﺠﺎﺯﻫـﺎ‬ ‫ﻭﺍﺴﺘﺨﺩﺍﻤﻬﺎ.‬ ‫اﻟﻘﺮص اﻟﻤﺪﻣﺞ ‪CD-ROM‬‬ ‫ﻴﺤﺘﻭﻱ ﺍﻟﻘﺭﺹ ﺍﻟﻤﺩﻤﺞ ﺍﻟﻤﺭﻓﻕ ﻤﻊ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻋﻠﻰ ﺠﻤﻴﻊ ﺍﻟﺸﻴﻔﺭﺍﺕ ﺍﻟﻤﺼﺩﺭﻴﺔ ﺍﻟﺘﻲ ﺍﻀـﻴﻑ ﺍﻟﺭﻤـﺯ‬ ‫ﻓﻲ ﺍﻋﻼﻫﺎ، ﻤﻘﺴﻤﺔ ﺍﻟﻰ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﻤﺠﻠﺩﺍﺕ ﺘﻤﺜل ﺭﻗﻡ ﺍﻟﻔﺼل ﺍﻟﺫﻱ ﺴﻁﺭﺕ ﻓﻲ ﺍﻟﺸﻴﻔﺭﺓ. ﻜﻤـﺎ ﺘﻌﻤـﺩﺕ‬ ‫ﺍﻀﺎﻓﺔ ﻤﻠﻔﺎﺕ ﺼﻭﺭ )ﻤﻥ ﺍﻟﻨﻭﻉ ‪ (JPG‬ﺘﻤﺜل ﺍﻟﺼﻭﺭ ﻭﺍﻻﺸﻜﺎل ﺍﻟﺘﻭﻀـﻴﺤﻴﺔ ﺍﻟﻤﻌﺭﻭﻀـﺔ ﻓـﻲ ﺍﻟﻔﺼـﻭل،‬ ‫ﻭﺫﻟﻙ ﺨﺸﻴﺔ ﻋﺩﻡ ﻭﻀﻭﺤﻬﺎ ﺒﻴﻥ ﺼﻔﺤﺎﺕ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ. ﻜﻤﺎ ﻴﻤﻜﻨﻙ ﺍﻴﺠـﺎﺩ ﺍﻟﻤﻠـﻑ ‪ArabicConsole.DLL‬‬ ‫ﻭﺍﻟﺫﻱ ﻁﻭﺭﺘﻪ ﻟﻤﺤﺎﻜﺎﺓ ﺍﻟﻜﺎﺌﻥ ‪ Console‬ﻓﻲ ﺍﻟﺩﻟﻴل ﺍﻟﺠﺫﺭﻱ ﻟﻠﻘﺭﺹ -ﺴﺎﺨﺒﺭﻙ ﺒـﻪ ﻻﺤﻘـﺎ ﻓـﻲ ﺍﻟﻔﺼـل‬ ‫ﺍﻻﻭل ﺘﻌﺭﻑ ﻋﻠﻰ ‪.Visual Basic .NET‬‬ ‫ﺻﻔﺤﺔ اﻟﻜﺘﺎب ﻋﻠﻰ اﻻﻧﺘﺮﻧﺖ‬ ‫ﻻ ﺍﻭﺩ ﺍﻨﻬﺎﺀ ﻋﻼﻗﺘﻲ ﻤﻌﻙ ﻤﻊ ﺍﻟﺼﻔﺤﺔ ﺍﻻﺨﻴﺭﺓ ﻤﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ، ﺒل ﺴﻴﻜﻭﻥ ﺸﺭﻑ ﻟﻲ ﺘﻤﺩﻴﺩﻫﺎ ﺍﻟـﻰ ﻓﺘـﺭﺍﺕ‬ ‫ﺍﻁﻭل. ﻴﻤﻜﻨﻙ ﻋﺯﻴﺯ ﺍﻟﻘﺎﺭﺉ ﺍﺼﻁﻴﺎﺩﻱ ﻋﻠﻰ ﺸﺒﻜﺔ ﺍﻻﻨﺘﺭﻨﺕ ﺍﻤـﺎ ﻋـﻥ ﻁﺭﻴـﻕ ﻤﺭﺍﺴـﻠﺘﻲ ﻋﻠـﻰ ﺒﺭﻴـﺩﻱ‬ ‫ﺍﻻﻟﻜﺘﺭﻭﻨﻲ ﺍﻭ ﻤﻥ ﺨﻼل ﺯﻴﺎﺭﺓ ﺼﻔﺤﺔ ﺍﻟﻜﺘﺎﺏ ﺍﻥ ﻜﻨﺕ ﺘﺭﻏـﺏ ﻓـﻲ ﺍﻟﺤﺼـﻭل ﻋﻠـﻰ ﺍﺨـﺭ ﺍﻟﺘﺤـﺩﻴﺜﺎﺕ‬ ‫ﻭﺘﺼﺤﻴﺢ ﺍﻻﺨﻁﺎﺀ ﺍﻟﻤﺘﻌﻠﻘﺔ ﺒﻪ، ﻭﺫﻟﻙ ﺒﺘﻭﺠﻴﻪ ﻤﺘﺼﻔﺤﻙ ﺍﻟﻰ ﺍﻟﻌﻨﻭﺍﻥ ﺍﻟﺘﺎﻟﻲ:‬ ‫‪http://www.dev4arabs.com/ar‬‬
  • 27.
    ‫ز‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫اﻻﺧﻄﺎء )هﺎمﺟﺪا(‬ ‫ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﺍﻟﻜﻤﺎل ﺸﺊ ﻻ ﻴﺘﻡ ﺍﻻ ﺒﺎﻟﻘﺩﺭﺓ ﺍﻻﻟﻬﻴﺔ، ﻭﺍﻟﻌﻤل ﺍﻟﺫﻱ ﺍﻤﺎﻡ ﻋﻴﻨﻴﻙ ﺠﻬﺩ ﺒﺸـﺭﻱ ﻤﻌـﺭﺽ ﺒﻨﺴـﺒﺔ‬ ‫ﻜﺒﻴﺭﺓ ﻟﻠﺨﻁﺄ، ﻴﻬﻤﻨﻲ ﺠﺩﺍ ﺍﻟﺘﻘﻠﻴل ﻤﻥ ﺍﻻﺨﻁﺎﺀ ﻓﻲ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ، ﺤﺘـﻰ ﻴﻜـﻭﻥ ﻤﺭﺠﻌـﺎ ﻋﺭﺒﻴـﺎ ﺴـﻠﻴﻤﺎ ﻤـﻥ‬ ‫ﺍﻟﺸﻭﺍﺌﺏ. ﻓﻲ ﺤﺎﻟﺔ ﺍﻟﻌﺜﻭﺭ ﻋﻠﻰ ﺍﻱ ﺨﻁﺄ )ﺴﻭﺍﺀ ﻟﻐﻭﻱ ﺍﻭ ﺘﻘﻨﻲ(، ﺒﺭﺠﺎﺀ ﺍﺒﻼﻏﻲ ﻓﻭﺭﺍ ﻋـﻥ ﺍﻟﺨﻁـﺄ ﻭﺭﻗـﻡ‬ ‫ﺍﻟﺼﻔﺤﺔ ﺍﻟﺫﻱ ﻭﻗﻊ ﻓﻴﻪ، ﻭﺒﻬﺫﺍ ﺘﺴﺩﻱ ﻟﻲ ﺨﺩﻤﺔ ﺴﺎﻜﻭﻥ ﺸﺎﻜﺭﺍ ﻭﻤﻘﺩﺭﺍ ﻟﻬﺎ.‬ ‫آﻠﻤﺔ اﺧﻴﺮة‬ ‫ﺍﺨﻲ ﺍﻟﻤﺒﺭﻤﺞ ﺍﻟﻌﺭﺒﻲ ﻤﻥ ﺍﻟﻤﺤﻴﻁ ﺍﻟﻰ ﺍﻟﺨﻠﻴﺞ، ﺒﻭﺩﻱ ﺘﻭﻀﻴﺢ ﻨﻘﻁﺔ ﻀﺭﻭﺭﻴﺔ ﺘﺘﻤﺤﻭﺭ ﺤﻭل ﻤﺅﻟـﻑ ﺍﻟﻜﺘـﺎﺏ‬ ‫ﺍﻟﺫﻱ ﺘﻘﺭﺃﻩ ﺍﻻﻥ. ﺼﺤﻴﺢ ﺍﻥ ﻓﻥ ﺍﻟﻜﺘﺎﺒﺔ ﺒﻌﻴﺩ ﻜل ﺍﻟﻤﺒﻌﺩ ﻋﻥ ﻤﺠﺎل ﻋﻤﻠﻲ ﺍﻻ ﺍﻨﻪ ﻋﻠﻴﻙ ﻤﻌﺭﻓﺔ ﺍﻨﻨـﻲ ﻤﺒـﺭﻤﺞ‬ ‫ﻭﻟﺴﺕ ﻜﺎﺘﺏ، ﻓﻠﺴﺕ ﻤﻥ ﺍﻟﺫﻴﻥ ﻟﺩﻴﻬﻡ ﺍﻋﻤﺩﺓ ﻓﻲ ﺍﻟﺼﺤﻑ ﻭﺍﻟﻤﺠﻼﺕ ﻭﻴﻬـﻭﻯ ﻜﺘﺎﺒـﺔ ﺍﻟﻤﻘـﺎﻻﺕ، ﺒـل ﺍﻗـﻭﻡ‬ ‫ﺒﻜﺘﺎﺒﺔ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ ﻭﺍﻟﺒﺭﺍﻤﺞ ﻟﻤﺨﺘﻠﻑ ﺍﻟﻘﻁﺎﻋﺎﺕ. ﻜﻤﺎ ﻟـﺩﻱ ﺍﻟﻜﺜﻴـﺭ ﻤـﻥ ﺍﻟﻌﻼﻗـﺎﺕ ﺒـﻴﻥ ﻋﻤﺎﻟﻘـﺔ‬ ‫ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﻓﻲ ﺍﻨﺤﺎﺀ ﺍﻟﻤﻌﻤﻭﺭﺓ ﻭﻗﺩ ﺍﺴﺘﻔﺩﺕ ﺍﻟﻜﺜﻴﺭ ﻭﺍﻟﺸﺊ ﺍﻟﻜﺒﻴﺭ ﻤﻥ ﺍﺤﺘﻜﺎﻜﻲ ﻤﻌـﻪ. ﻭﺍﻋﺘﻘـﺩ –ﺒـل ﺍﻜـﺎﺩ‬ ‫ﺍﺠﺯﻡ - ﺍﻨﻙ ﻟﻡ ﺘﻘﺘﻨﻲ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻟﺘﺘﻌﻠﻡ ﻓﻥ ﺍﻟﺒﻼﻏﺔ ﺍﻭ ﺍﻻﺴﺘﻤﺘﺎﻉ ﺒﺎﻟﺘﻌﺎﺒﻴﺭ ﺍﻟﻠﻐﻭﻴﺔ، ﺒـل ﺘﺭﻴـﺩ ﺍﻥ ﺘـﺘﻌﻠﻡ ﻟﻐـﺔ‬ ‫ﺒﺭﻤﺠﺔ ﺍﺴﻤﻬﺎ ‪ .Visual Basic .NET‬ﻟﺫﻟﻙ، ﺤﺎﻭل ﺘﺠﺎﻫل ﻗﺩﺭ ﺍﻻﻤﻜـﺎﻥ ﺘﻌـﺎﺒﻴﺭﻱ ﺍﻟﻠﻐﻭﻴـﺔ ﺍﻟﺭﻜﻴﻜـﺔ،‬ ‫ﻭﻀﻌﻑ ﺍﺴﻠﻭﺒﻲ ﺍﻟﺒﻼﻏﻲ ﻭﺍﻟﻜﺘﺎﺒﻲ، ﻭﻟﻨﺠﻌل ﻟﻐﺔ ﺍﻟﺸـﻴﻔﺭﺍﺕ ﺍﻟﻤﺼـﺩﺭﻴﺔ ‪ Source Codes‬ﻫـﻲ ﺍﻟﻘﺎﺴـﻡ‬ ‫ﺍﻟﻤﺸﺘﺭﻙ ﺒﻴﻨﻨﺎ.‬ ‫ﺍﻟﻔﺘﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ ﺍﻟﺘﻲ ﻗﻀﻴﺘﻬﺎ ﻓﻲ ﻜﺘﺎﺒﺔ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻜﺎﻨﺕ ﻁﻭﻴﻠﺔ ﺒﻌﺽ ﺍﻟﺸﺊ ﻭﺍﻟﻭﻗـﺕ ﻗﺼـﻴﺭ ﺠـﺩﺍ،‬ ‫ﻭﻟﻡ ﺍﺴﺘﻁﻊ –ﺒﺼﺭﺍﺤﺔ ﺸﺩﻴﺩﺓ - ﻜﺘﺎﺒﺔ ﻜل ﺍﻟﺘﻔﺎﺼﻴل ﺍﻟﺘﻲ ﻭﺩﺩﺕ ﺫﻜﺭﻫﺎ ﻓﻲ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ، ﻟﺫﻟﻙ ﻭﻀـﻌﺕ ﻓـﻲ‬ ‫ﻋﻴﻥ ﺍﻋﺘﺒﺎﺭﻱ ﻗﺩﺭﺓ ﺍﻟﻘﺎﺭﺉ ﻋﻠﻰ ﺍﻟﺘﻌﻠﻡ ﺍﻟﺫﺍﺘﻲ، ﺤﻴﺙ ﻜﺎﻥ ﻫﺩﻓﻲ ﺍﻋﻁﺎﺌﻙ ﻤﻔﺘـﺎﺡ ﻭﻤـﺩﺨل ﻟﻤﺴـﺎﺌل ﻋﺩﻴـﺩﺓ‬ ‫ﻭﺘﺭﻜﺕ ﺍﻟﺒﺎﻗﻲ ﻋﻠﻴﻙ ﻟﻠﺒﺤﺙ ﻋﻥ ﺍﻟﺘﻔﺎﺼﻴل ﺍﻻﺨﺭﻯ ﺴﻭﺍﺀ ﻓـﻲ ﻤﻭﺍﻗـﻊ ﺍﻻﻨﺘﺭﻨـﺕ ﺍﻭ ﻤﺴـﺘﻨﺩﺍﺕ ﻭﻤﺭﺍﺠـﻊ‬ ‫‪ .NET Documentation‬ﺍﻟﺭﺴﻤﻴﺔ.‬ ‫ﺒﺭﻤﺠﺔ ﺍﻁﺎﺭ ﻋﻤل ‪ .NET‬ﺒﺎﺴﺘﺨﺩﺍﻡ ‪ Visual Basic .NET‬ﻤﺎﻫﻭ ﺍﻻ ﻤﺤﺎﻭﻟـﺔ ﺠـﺎﺩﺓ ﻟﺘـﺄﻟﻴﻑ‬ ‫ﻜﺘﺎﺏ ﻋﺭﺒﻲ ﻤﻥ ﻤﺅﻟﻑ ﻋﺭﺒﻲ ﻭﻤﻭﺠﻪ ﺍﻟﻰ ﻤﺒﺭﻤﺞ ﻋﺭﺒﻲ ﻟﺘﻘﺩﻴﻡ ﻜل ﻤﺎ ﻴﺤﺘﺎﺠﻪ ﻤﻥ ﻤﻌﻠﻭﻤـﺎﺕ ﺘﻤﻜﻨـﻪ ﻤـﻥ‬ ‫ﺒﻨﺎﺀ ﺘﻁﺒﻴﻘﺎﺕ ﻭﺤﻠﻭل ﻋﻤﻠﻴﺔ ﻤﻭﺠﻪ ﺍﻟـﻰ ﺍﻁـﺎﺭ ﻋﻤـل ‪ .NET Framework‬ﺒﺎﺴـﺘﺨﺩﺍﻡ ﻟﻐـﺔ ﺍﻟﺒﺭﻤﺠـﺔ‬ ‫‪ ،Visual Basic .NET‬ﺒﺩﺀﺍ ﻤﻥ ﺘﻭﻀﻴﺢ ﺍﺴﺎﺴﻴﺎﺕ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠـﺔ ﻭﺍﻨﺘﻬﺎﺌـﺎ ﺒﺘﻁـﻭﻴﺭ ﺘﻁﺒﻴﻘـﺎﺕ ﻤﺨﺘﻠﻔـﺔ‬ ‫ﺍﻟﻤﺠﺎﻻﺕ ﺩﺍﻋﻤﺔ ﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ. ﺍﺘﻤﻨﻰ ﺍﻥ ﺍﻜﻭﻥ ﻗﺩ ﻭﻓﻘﺕ ﻓﻲ ﻤﺤـﺎﻭﻟﺘﻲ ﻫـﺫﻩ ﻭﻗـﺩﻤﺕ ﻤـﺎ ﻴﺭﻀـﻲ ﺫﻭﻕ‬ ‫ﺍﻟﻤﺒﺭﻤﺞ ﺍﻟﻌﺭﺒﻲ ... ﺤﻅﺎ ﺴﻌﻴﺩﺍ!‬ ‫ﺘﺭﻜﻲ ﺍﻟﻌﺴﻴﺭﻱ‬ ‫ﺍﻟﻅﻬﺭﺍﻥ – ﻓﺒﺭﺍﻴﺭ 3002‬ ‫‪.turki@dev4arabs.com‬‬
  • 29.
    ‫1‬ ‫اﻟﻔﺼﻞ اﻻول‬ ‫ﺗﻌﺮف ﻋﻠﻰ‪Visual Basic .NET‬‬ ‫ﺒﺴﻡ ﺍﷲ ﻨﺒﺩﺃ ﻭﻋﻠﻰ ﺒﺭﻜﺘﻪ ﻨﺴﻴﺭ ﻤﻊ ﺍﻟﺠﻤﻠﺔ ‪ ،Visual Basic .NET‬ﺘﺘﻜﻭﻥ ﻫﺫﻩ ﺍﻟﺠﻤﻠـﺔ ﻤـﻥ 41 ﺤﺭﻓـﺎ‬ ‫ﻭﻨﻘﻁﺔ ﻭﺍﺤﺩﺓ، ﺍﻟﺤﺭﻭﻑ ﺍﻟـ 11 ﺍﻻﻭﻟﻰ ﺘﻌﻨﻲ ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﺍﺴـﻤﻬﺎ ‪ ،Visual Basic‬ﻭﺍﻟﻨﻘﻁـﺔ ﻭﺍﻟﺤـﺭﻭﻑ‬ ‫ﺍﻟﺜﻼﺙ ﺍﻻﺨﻴﺭﺓ ﺘﻌﻨﻲ ﺍﻁﺎﺭ ﻋﻤل ‪ .NET Framework‬ﻟﺫﻟﻙ، ﻴﻤﻜﻨﻨﺎ ﺍﻥ ﻨﻁﻠﻕ ﻋﻠﻰ ﻫﺫﻩ ﺍﻟﻠﻐـﺔ ‪Visual‬‬ ‫‪) Basic for .NET Framework‬ﺍﻱ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ‪ Visual Basic‬ﺍﻟﻤﻭﺠﻬﻪ ﺍﻟﻰ ﺍﻁﺎﺭ ﻋﻤل ‪.NET‬‬ ‫‪.(Framework‬‬ ‫ﺭﺤﻠﺔ ﺍﻻﻟﻑ ﻤﻴل ﺘﺒﺩﺃ ﺒﺨﻁﻭﺓ، ﻭﺨﻁﻭﺘﻨﺎ ﺍﻻﻭﻟﻰ ﻓﻲ ﺭﺤﻠﺘﻨـﺎ ﻤـﻊ ‪ Visual Basic .NET‬ﺴـﺘﻜﻭﻥ‬ ‫ﻨﻅﺭﻴﺔ ﺒﺤﺘﺔ. ﻓﻘﺒل ﺍﻥ ﺘﺒﺩﺃ ﺒﻔﺭﻗﻌﺔ ﺍﻨﺎﻤﻠﻙ ﻟﻜﺘﺎﺒﺔ ﺍﻟﺸﻴﻔﺭﺍﺕ ﻭﺒﻨﺎﺀ ﺒﺭﺍﻤﺠﻙ، ﻤﻥ ﺍﻟﺠﻴـﺩ ﺍﺨـﺫ ﻓﻜـﺭﺓ ﻤﺒﺴـﻁﺔ‬ ‫ﻋﻥ ﺍﻟﺤﺭﻭﻑ ﺍﻟﺸﻬﻴﺭﺓ ‪ .NET‬ﻭﻤﻌﺭﻓﺔ ﻤﺎﺫﺍ ﺘﻌﻨﻲ ﻫﺫﻩ ﺍﻟﺤﺭﻭﻑ، ﻭﻤﺎ ﺍﻟﺫﻱ ﺘﻘﺩﻤﻪ ﻟﻙ، ﻭﻤـﺎ ﻫـﻲ ﺍﻟﺤﺎﺠـﺔ‬ ‫ﺍﻟﺘﻲ ﺘﺩﻋﻭﻨﺎ –ﺃﻨﺕ ﻭﺃﻨﺎ ﻋﻠﻰ ﺍﻻﻗل - ﻟﻼﻨﺘﻘﺎل ﺍﻟﻰ ﺒﺭﻤﺠﺔ ﺍﻁـﺎﺭ ﻋﻤـل ‪ .NET Framework‬ﻭﺍﺫﺍ ﻜﻨـﺕ‬ ‫ﻤﻥ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺍﻟﻤﺨﻀﺭﻤﻴﻥ، ﻓﺴﻴﻜﻭﻥ ﻫﺫﺍ ﺍﻟﻔﺼل ﻤﺼﺩﺭ ﻻﻓـﺭﺍﻍ ﺠﻤﻴـﻊ ﻤﻌﺎﻨﺎﺘـﻙ ﺍﻟﺴـﺎﺒﻘﺔ ﻤـﻊ ﻋـﺎﻟﻡ‬ ‫ﺍﻟﺒﺭﻤﺠﺔ، ﺍﻤﺎ ﺍﻥ ﻜﺎﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﺍﻭل ﻜﺘﺎﺏ ﺒﺭﻤﺠﺔ ﺘﻘﺭﺃﻩ ﻓﻲ ﺤﻴﺎﺘﻙ، ﻓﺎﻋﺘﺒﺭ ﻨﻔﺴﻙ ﻤﺒﺭﻤﺞ ﻤﺤﻅـﻭﻅ ﺠـﺩﺍ‬ ‫ﻟﻤﺎ ﺴﺘﻜﺘﺸﻔﻪ ﻤﻥ ﺍﻟﺘﻌﻘﻴﺩﺍﺕ ﺍﻟﺘﻲ ﻜﺎﻨﺕ ﺘﻭﺍﺠﻪ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﻗﺒل ﺘﻘﻨﻴﺔ ‪.NET‬‬ ‫اﻟﺤﻴﺎة ﻗﺒﻞ ‪.NET‬‬ ‫ﻟﺴﺕ ﻫﻨﺎ ﺒﺼﺩﺩ ﺘﺄﻟﻴﻑ ﻜﺘﺎﺏ ﺘﺎﺭﻴﺦ ﺍﻭ ﺍﻟﺘﺤﺩﺙ ﻋﻥ ﺒﺩﺍﻴﺎﺕ ﻅﻬﻭﺭ ﺍﻟﺤﺎﺴﺒﺎﺕ ﺍﻟﺸﺨﺼﻴﺔ، ﻓﻔـﻲ ﺫﻟـﻙ ﺍﻟـﺯﻤﻥ‬ ‫ﻟﻡ ﺍﻜﻥ ﺸﻴﺌﺎ ﻤﺫﻜﻭﺭﺍ. ﻭﻟﻜﻥ ﻤﺎ ﺍﻨﺎ ﺒﺼﺩﺩﺓ ﺍﻵﻥ ﻫﻭ ﺘﻘﺩﻴﻡ ﻋﺭﺽ ﻤﻘﺘﻀﺏ ﻭﺴـﺭﻴﻊ ﻻﺴـﺎﻟﻴﺏ ﺒﻨـﺎﺀ ﺍﻟﺒـﺭﺍﻤﺞ‬ ‫ﹰ‬ ‫ﻤﻨﺫ ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ‪ DOS‬ﻭﺤﺘﻰ ﻟﺤﻅﺔ ﻜﺘﺎﺒﺔ ﻫﺫﻩ ﺍﻟﺴـﻁﻭﺭ، ﻭﺴـﻴﻜﻭﻥ ﺤـﺩﻴﺜﻲ ﻤﻭﺠﻬـﺎ ﻟﻤﺒﺭﻤﺠـﻲ ﻨﻅـﻡ‬ ‫ﹰ‬ ‫‪ Microsoft‬ﺒﺸﻜل ﺤﺼﺭﻱ.‬ ‫اﻟﺒﺮﻣﺠﺔ ﺗﺤﺖ ﻧﻈﻢ ‪DOS‬‬ ‫ﻜﺎﻥ ﻜل ﻤﺎﻫﻭ ﻤﻁﻠﻭﺏ ﻤﻨﻙ -ﻜﻤﺒﺭﻤﺞ - ﺍﺴﺘﺨﺩﺍﻡ ﺍﻤﺭ ‪ Input‬ﻟﻘﻨﺹ ﺍﻟﻤـﺩﺨﻼﺕ ﻤـﻥ ﺍﻟﻤﺴـﺘﺨﺩﻡ، ﻭﺍﻻﻤـﺭ‬ ‫‪ Print‬ﻟﻌﺭﺽ ﺍﻟﻤﺨﺭﺠﺎﺕ ﻋﻠﻰ ﺍﻟﺸﺎﺸﺔ، ﺒﺎﻻﻀﺎﻓﺔ ﺍﻟﻰ ﺍﺴﺘﺨﺩﺍﻡ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﻌﺒﺎﺭﺍﺕ ﻟﺘﻁﺒﻴـﻕ ﺍﻟﻌﻤﻠﻴـﺎﺕ‬ ‫ﺍﻟﺤﺴﺎﺒﻴﺔ. ﻜﺎﻨﺕ ﻓﻲ ﺍﻟﺤﻘﻴﻘﺔ ﺒﺭﻤﺠﺔ ﺴﻬﻠﺔ ﻭﻤﻤﺘﻌﺔ ﻟﻠﻤﺒﺭﻤﺠﻴﻥ، ﺤﺘﻰ ﺍﺼﺒﺢ ﻜل ﻤﻥ ﻫـﺏ ﻭﺩﺏ ﻴـﺩﻋﻲ ﺍﻨـﻪ‬ ‫ﻤﺒﺭﻤﺞ، ﺍﻻ ﺍﻥ ﺍﻟﻨﺘﻴﺠﺔ ﻜﺎﻨﺕ ﺒﺭﺍﻤﺞ ﻤﺘﺸﺎﺒﻬﺔ، ﻻ ﺠﺩﻴﺩ ﻓﻴﻬﺎ ﻭﻻ ﺘﺴﺘﺨﺩﻡ ﺘﻘﻨﻴﺎﺕ ﺠﺩﻴﺩﺓ.‬
  • 30.
    ‫4‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺒﻌﺩ ﺫﻟﻙ، ﻅﻬﺭﺕ ﺍﻟﺤﺎﺠﺔ ﺍﻟﻰ ﺍﻟﺘﺤﻠﻴﻕ ﺍﻟﻰ ﻤﺩﻯ ﺍﺒﻌﺩ ﻤﻥ ﺍﻻﺴﻠﻭﺏ ﺍﻟﺴﺎﺒﻕ، ﻓﻜﺎﻨﺕ ﺍﻫـﺩﺍﻑ ﺍﻟﺘﺤﻠﻴـﻕ‬ ‫-ﺒﺸﻜل ﻤﺒﺩﺌﻲ - ﺍﻟﺘﻔﺎﻋل ﻤﻊ ﺍﻻﺠﻬﺯﺓ ‪ Devices‬ﺍﻟﺘﻲ ﺘﺭﻜﺏ ﻓﻲ ﺍﻟﺠﻬـﺎﺯ )ﻜﺎﻟﻁﺎﺒﻌـﺔ، ﺒﻁﺎﻗـﺔ ﺍﻟﺼـﻭﺕ،‬ ‫ﺍﻟﻔﺄﺭﺓ ...ﺍﻟﺦ(، ﺍﻻ ﺍﻥ ﺍﺠﻨﺤﺔ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﻓﻲ ﺫﻟﻙ ﺍﻟﻭﻗﺕ ﻜﺎﻨﺕ ﺘﻌﺘﻤﺩ ﺍﻋﺘﻤﺎﺩﺍ ﻜﻠﻴﺎ ﻋﻠـﻰ ﺒﺭﻴﻤﺠﻴـﺎﺕ ﺘﺎﺒﻌـﺔ‬ ‫ﹰ ﹰ‬ ‫ﺘﺴﻤﻰ ﺍﻟﻤﺸﻐﻼﺕ ‪ .Drivers‬ﻤﻌﻅﻡ ﻫﺫﻩ ﺍﻟﻤﺸﻐﻼﺕ ﻜﺎﻨﺕ ﺘﻨﺠـﺯ ﺒﻠﻐـﺔ ﺍﻟﺘﺠﻤﻴـﻊ ‪ ،Assembly‬ﻭﺘﺘﻁﻠـﺏ‬ ‫ﺨﺒﺭﺓ ﻜﺒﻴﺭﺓ ﻓﻲ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻤﻌﺎﻟﺞ ﻭﻋﺘﺎﺩ ﺍﻟﻜﻤﺒﻴﻭﺘﺭ. ﻓﻠﻭ ﻗﻤﺕ ﺒﻌﻤل ﺒﺭﻨـﺎﻤﺞ ﻴﻁﺒـﻊ ﺍﻟﻨﺘـﺎﺌﺞ ﻋﻠـﻰ ﻭﺭﻕ‬ ‫ﺍﻟﻁﺎﺒﻌﺔ، ﻓﻌﻠﻴﻙ ﺍﺭﻓﺎﻕ ﻤﺸﻐل ﺍﻟﻁﺎﺒﻌﺔ ﻤﻊ ﺍﻟﺒﺭﻨﺎﻤﺞ، ﻭﺍﺫﺍ ﺍﺭﺩﺕ ﻤﻥ ﺒﺭﻨﺎﻤﺠﻙ ﺃﻥ ﻴﻌـﺯﻑ ﻤﻠـﻑ ﺼـﻭﺘﻲ،‬ ‫ﻋﻠﻴﻙ ﺍﺭﻓﺎﻕ ﻤﺸﻐل ﺍﻟﺼﻭﺕ.‬ ‫ﻗﺩ ﺘﺒﺩﻭ ﻓﻜﺭﺓ ﺍﺭﻓﺎﻕ ﻤﻠﻔﺎﺕ ﺍﻟﻤﺸﻐﻼﺕ ﻤﻘﺒﻭﻟﺔ -ﺍﻟﻰ ﺤﺩ ﻤﺎ - ﻟـﺒﻌﺽ ﺍﻟﻤﺒـﺭﻤﺠﻴﻥ، ﺍﻻ ﺍﻥ ﺍﻟﻤﺸـﻜﻠﺔ‬ ‫ﺍﻟﺤﻘﻴﻘﺔ ﺍﻟﺘﻲ ﻜﻨﺎ ﻨﻭﺍﺠﻬﻬﺎ ﻫﻲ ﺍﻥ ﻟﻜل ﻁﺎﺒﻌﺔ ﻤﺸﻐل ﺨﺎﺹ ﺒﻬﺎ. ﻭﺒﻤﺎ ﺃﻨﻪ ﻟﻴﺱ ﻟﺩﻴﻨﺎ ﺍﻱ ﻓﻜـﺭﺓ ﻋـﻥ ﻨﻭﻋﻴـﺔ‬ ‫ﺍﻟﻁﺎﺒﻌﺔ ﺍﻟﺘﻲ ﺴﺘﻜﻭﻥ ﻋﻠﻰ ﻁﺎﻭﻟﺔ ﺍﻟﻤﺴﺘﺨﺩﻡ، ﻓﺈﻥ ﺫﻟﻙ ﻴﻔـﺭﺽ ﻋﻠﻴﻨـﺎ ﺍﺭﻓـﺎﻕ ﻤﺸـﻐﻼﺕ ﻟﺠﻤﻴـﻊ ﺍﻨـﻭﺍﻉ‬ ‫ﺍﻟﻁﺎﺒﻌﺎﺕ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﺴﻭﻕ. ﻓﻠﻭ ﺘﺫﻜﺭ ﺒﺭﻨﺎﻤﺞ 321 ‪ Lotus‬ﺍﻟـﺫﻱ ﻴﻌﻤـل ﺘﺤـﺕ ﻨﻅـﺎﻡ ‪،MS-DOS‬‬ ‫ﺴﺘﻌﻠﻡ ﺍﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻴﺭﻓﻕ ﻤﻌﻪ ﺍﻜﺜﺭ ﻤﻥ 002 ﻤﻠﻑ، ﻫﺫﻩ ﺍﻟﻤﻠﻔـﺎﺕ ﻤـﺎﻫﻲ ﺍﻻ ﻤﺸـﻐﻼﺕ ﻟﻤﺨﺘﻠـﻑ ﺍﻨـﻭﺍﻉ‬ ‫ﺍﻟﻁﺎﺒﻌﺎﺕ! ﺒﺎﻟﻨﺴﺒﺔ ﻟﻲ، ﻜﻨﺕ ﺍﻓﻀل ﺍﺴﺘﺨﺩﺍﻡ ﻴﺩﻱ ﻟﻜﺘﺎﺒﺔ ﺍﻟﻨﺘﺎﺌﺞ ﻋﻠﻰ ﺍﻟﻭﺭﻕ ﺒﺩﻻ ﻤـﻥ ﺘﺤﻤـل ﺘﻜـﺎﻟﻴﻑ ﻨﺴـﺦ‬ ‫ﺍﻻﻗﺭﺍﺹ )ﻜﺎﻨﺕ ﻏﺎﻟﻴﺔ ﺠﺩﺍ ﻓﻲ ﺫﻟﻙ ﺍﻟﻭﻗﺕ( ﻟﻭﻀﻊ ﻤﺸﻐﻼﺕ ﺍﻟﻁﺎﺒﻌﺎﺕ ﻋﻠﻴﻬﺎ.‬ ‫اﻻﻧﺘﻘﺎل اﻟﻰ ‪Windows‬‬ ‫ﺍﻤﺎ ﻤﻊ ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ‪ Windows‬ﻓﻘﺩ ﺤﻠﺕ ﺍﻟﻤﺸﻜﻠﺔ ﺍﻟﺴﺎﺒﻘﺔ، ﺒﺤﻴﺙ ﻴﺘﻜﻔل ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ﺒﻤﻬﻤـﺔ ﺍﻟﺘﻌـﺭﻑ‬ ‫ﻋﻠﻰ ﻋﺘﺎﺩ ﺍﻟﻜﻤﺒﻴﻭﺘﺭ ﻭﺍﺭﻓﺎﻕ ﻤﺸﻐﻼﺘﻬﺎ، ﻓﻬﻭ ﻴﻭﻓﺭ ﻟﻙ ﺍﻤﻜﺎﻨﻴﺔ ﺍﻟﻁﺒﺎﻋﺔ ﻓﻲ ﺒﺭﻨﺎﻤﺠﻙ ﺩﻭﻥ ﺍﻟﺤﺎﺠـﺔ ﻟﻤﻌﺭﻓـﺔ‬ ‫ﻨﻭﻋﻴﺔ ﺍﻟﻁﺎﺒﻌﺔ، ﻭﻴﻤﻜﻨﻙ ﻤﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺼﻭﺭ ﻭﺍﻟﺭﺴﻭﻡ ﺍﻭ ﻋﺯﻑ ﻤﻠﻔﺎﺕ ﺍﻟﺼـﻭﺕ ﺍﻭ ﺍﺴـﺘﺨﺩﺍﻡ ﺍﻟﻔـﺄﺭﺓ ﻓـﻲ‬ ‫ﺒﺭﻨﺎﻤﺠﻙ ﺩﻭﻥ ﺍﻻﻟﺘﺯﺍﻡ ﺒﺎﺭﻓﺎﻕ ﻤﺸﻐﻼﺕ ﺍﻻﺠﻬﺯﺓ، ﺍﻱ ﻜل ﻤﺎﻫﻭ ﻤﻁﻠﻭﺏ ﻤﻨﻙ -ﻜﻤﺒـﺭﻤﺞ - ﺍﻟﺘﺭﻜﻴـﺯ ﻋﻠـﻰ‬ ‫ﺒﺭﻨﺎﻤﺠﻙ ﻭﺼﺭﻑ ﺍﻟﻨﻅﺭ ﻋﻥ ﺍﻻﻤﻭﺭ ﺍﻟﺘﻘﻨﻴﺔ ﺍﻟـﺩﻨﻴﺎ ﻜـﺎﻻﺠﻬﺯﺓ ﻭﺍﻟﻌﺘـﺎﺩ، ﺍﺩﺍﺭﺓ ﺍﻟـﺫﺍﻜﺭﺓ، ﺍﺩﺍﺭﺓ ﺍﻻﻗـﺭﺍﺹ‬ ‫ﻭﻏﻴﺭﻫﺎ، ﻭﺍﻟﺘﻲ ﻴﺘﻜﻔل ﺒﻬﺎ ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ﺒﻜل ﺍﻗﺘﺩﺍﺭ.‬ ‫ﺍﻻ ﺍﻥ ﺍﻟﺒﺭﻤﺠﺔ ﺘﺤﺕ ﺒﻴﺌﺔ ‪ Windows‬ﺘﺨﺘﻠﻑ ﺍﺨﺘﻼﻓﺎ ﺠﺫﺭﻴﺎ ﻋـﻥ ﺍﻟﺒﺭﻤﺠـﺔ ﺘﺤـﺕ ﺒﻴﺌـﺔ ‪،DOS‬‬ ‫ﹰ‬ ‫ﻓﺒﺭﻨﺎﻤﺠﻙ ﻟﻡ ﻴﻌﺩ ﻴﺴﺘﺨﺩﻡ ﺍﻟﻁﺭﻕ ﺍﻟﺘﻘﻠﻴﺩﻴﺔ ﻟﻘﻨﺹ ﺍﻟﻤـﺩﺨﻼﺕ ﻭﻋـﺭﺽ ﺍﻟﻤﺨﺭﺠـﺎﺕ، ﻓﻘـﻨﺹ ﺍﻟﻤـﺩﺨﻼﺕ‬ ‫ﺍﺼﺒﺤﺕ ﺘﺘﻡ ﻤﻥ ﻗﺒل ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل، ﻭﺍﻟﺫﻱ ﻴﻘﻭﻡ ﺒﺎﺭﺴﺎﻟﻬﺎ ﻟـﻙ ﻋﻠـﻰ ﺸـﻜل ﺭﺴـﺎﺌل ‪ Messages‬ﻜـﺎﻟﻨﻘﺭ‬ ‫‪ ،Click‬ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ‪... KeyDown‬ﺍﻟﺦ. ﻟﺫﻟﻙ، ﺍﻨﻘﻠﺒﺕ ﺍﻟﻤـﻭﺍﺯﻴﻥ ﺍﻟﺒﺭﻤﺠﻴـﺔ ﻓـﻲ ﺤﻴـﺎﺓ ﻤﻌﻅـﻡ‬ ‫ﺍﻟﻤﺒﺭﻤﺠﻴﻥ، ﻟﺘﺼﺒﺢ ﺒﺭﺍﻤﺠﻬﻡ ﺘﺤﺘﻭﻱ ﻋﻠﻰ ﻋﺸﺭﺍﺕ -ﺒل ﻤﺌﺎﺕ - ﺍﻟﺤﻠﻘﺎﺕ ﺍﻟﺘﻜﺭﺍﺭﻴﺔ ﻟﻘﻨﺹ ﻫﺫﻩ ﺍﻟﺭﺴﺎﺌل.‬ ‫ﺍﻤﺎ ﻤﻥ ﻨﺎﺤﻴﺔ ﻋﺭﺽ ﺍﻟﻤﺨﺭﺠﺎﺕ، ﻓﻠﻡ ﻴﻌﺩ ﻫﻨﺎﻙ ﺸـﺊ ﺍﺴـﻤﻪ ‪ Print‬ﻻﻅﻬـﺎﺭ ﺍﻟﻤﺨﺭﺠـﺎﺕ ﻋﻠـﻰ‬ ‫ﺍﻟﺸﺎﺸﺔ، ﺤﻴﺙ ﻴﺘﻁﻠﺏ ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ‪ Windows‬ﻤﻥ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺍﻨﺸـﺎﺀ ﻨﻭﺍﻓـﺫ ﻭﺴـﻴﺎﻗﺎﺕ ﺭﺴـﻡ ﻭﺘﺴـﺠﻴل‬ ‫ﻁﺒﻘﺎﺕ ﻟﻴﺘﻤﻜﻨﻭﺍ ﻤﻥ ﻋﺭﺽ ﺍﻟﻤﺨﺭﺠﺎﺕ ﻤﻥ ﺨﻼﻟﻬﺎ. ﻓﻠﻭ ﺍﺭﺍﺩ ﻤﺒﺭﻤﺞ ﺘﻌﻠﻡ ﻟﻐﺔ ﺒﺭﻤﺠـﺔ ﺠﺩﻴـﺩﺓ ﻟﻜﺘﺎﺒـﺔ ﺍﻭل‬ ‫ﺒﺭﻨﺎﻤﺞ ﺸﻬﻴﺭ ‪ Hello World‬ﺘﺤﺕ ﺒﻴﺌﺔ ‪ ،Windows‬ﻋﻠﻴﻪ ﻜﺘﺎﺒﺔ ﻋﺸﺭﺍﺕ ﺍﻟﺴﻁﻭﺭ ﺍﻟﻤﻌﻘﺩﺓ ﺠـﺩﺍ ﻟﻌﻤـل‬ ‫ﺫﻟﻙ، ﺍﻻﻤﺭ ﺍﻟﺫﻱ ﺍﺩﻯ ﺘﻘﺎﻋﺩ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﻤﻥ ﻋﺎﻟﻡ ﺍﻟﻤﺒﺭﻤﺠﺔ ﻭﻓﻀﻠﻭﺍ ﺍﻟﻌﻤل ﻋﻨﺩ ﺸـﺭﻜﺎﺕ ﺴـﻴﺎﺭﺍﺕ ﺍﻻﺠـﺭﺓ‬
  • 31.
    V isual Basic.NET ‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮف ﻋﻠﻰ‬ 5 ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ ﻭﺍﻟﺘﻲ ﺘﻤﺜـل ﺒﺭﻨـﺎﻤﺞ ﻴﻘـﻭﻡ‬C ‫)ﺍﻟﺘﺎﻜﺴﻲ(!. ﻭﺤﺘﻰ ﺍﺭﻴﻙ ﺍﻻﻤﺭ ﺍﻟﻭﺍﻗﻊ، ﺍﻨﻅﺭ ﺇﻟﻰ ﻫﺫﻩ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﻤﻌﺩﺓ ﺒﻠﻐﺔ‬ :‫ﺒﻌﺭﺽ ﻨﺎﻓﺫﺓ ﺨﺎﻟﻴﺔ ﻓﻘﻁ‬ #include <windows.h> LRESULT CALLBACK MainWndProc( HWND, UINT, WPARAM, LPARAM ); HINSTANCE ghInstance; int PASCAL WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow ) } WNDCLASS wc; MSG msg; HWND hWnd; if( !hPrevInstance ) { wc.lpszClassName = "ShowWindow"; wc.lpfnWndProc = MainWndProc; wc.style = CS_OWNDC | CS_VREDRAW | CS_HREDRAW; wc.hInstance = hInstance; wc.hIcon = LoadIcon( NULL, IDI_APPLICATION ); wc.hCursor = LoadCursor( NULL, IDC_ARROW ); wc.hbrBackground = (HBRUSH)( COLOR_WINDOW+1 ); wc.cbClsExtra = 0; wc.cbWndExtra = 0; } RegisterClass( &wc ); ghInstance = hInstance; hWnd = CreateWindow ( "ShowWindow", "ShowWindow", WS_OVERLAPPEDWINDOW|WS_HSCROLL|WS_VSCROLL, 0, 0, 600, 300, NULL, NULL, hInstance, NULL); ShowWindow( hWnd, nCmdShow ); while( GetMessage( &msg, NULL, 0, 0 )) { TranslateMessage( &msg ); DispatchMessage( &msg ); } } return (int) msg.wParam;
  • 32.
    ‫6‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫,‪LRESULT CALLBACK MainWndProc( HWND hWnd, UINT msg, WPARAM wParam‬‬ ‫) ‪LPARAM lParam‬‬ ‫{‬ ‫;‪PAINTSTRUCT ps‬‬ ‫;‪HDC hDC‬‬ ‫{ ) ‪switch( msg‬‬ ‫:‪case WM_DESTROY‬‬ ‫;) 0 (‪PostQuitMessage‬‬ ‫;‪Break‬‬ ‫:‪default‬‬ ‫;)) ‪return( DefWindowProc( hWnd, msg, wParam, lParam‬‬ ‫}‬ ‫;0 ‪return‬‬ ‫}‬ ‫ﻭﻟﻭ ﺍﻨﻬﻡ ﺼﺒﺭﻭﺍ ﻟﻜﺎﻥ ﺨﻴﺭﺍ ﻟﻬﻡ، ﻓﺒﻌﺩ ﻓﺘﺭﺓ ﻟﻴﺴﺕ ﻁﻭﻴﻠﺔ ﻅﻬـﺭﺕ ﺤﻠـﻭل ﻤـﻥ ﻜﺒﺭﻴـﺎﺕ ﺸـﺭﻜﺎﺕ‬ ‫ﺼﻨﺎﻋﺔ ﺍﻟﺒﺭﻤﺠﻴﺎﺕ ﻟﺘﻬﺴﻴل ﻋﻤﻠﻴﺔ ﺍﻟﺒﺭﻤﺠﺔ ﺘﺤﺕ ﻨﻅـﻡ ‪ ،Windows‬ﻭﺫﻟـﻙ ﺒـﺎﺨﺘﺭﺍﻉ ﺍﻟﻜﻠﻤـﺔ ﺍﻟﺴـﺤﺭﻴﺔ‬ ‫‪ ،Visual‬ﻓﻜل ﻤﺎ ﻫﻭ ﻤﻁﻠﻭﺏ ﻤﻥ ﺍﻟﻤﺒﺭﻤﺞ ﺘﺼﻤﻴﻡ ﺸﺎﺸﺎﺕ )ﻨﻭﺍﻓﺫ( ﺒﺭﻨﺎﻤﺠﻪ ﺒﺎﻟﻔﺄﺭﺓ، ﻭﻜﺘﺎﺒﺔ ﺒﻀﻌﺔ ﺍﻭﺍﻤـﺭ‬ ‫ﻴﺘﻡ ﺘﻨﻔﻴﺫﻫﺎ ﺒﻤﺠﺭﺩ ﻗﻴﺎﻡ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺒﺎﻟﺘﻔﺎﻋل ﻤﻊ ﺒﺭﻨﺎﻤﺠﻪ ﺴـﻭﺍﺀ ﺒﺎﻟﻔـﺄﺭﺓ ﺍﻭ ﻟﻭﺤـﺔ ﺍﻟﻤﻔـﺎﺘﻴﺢ ﺍﻭ ﺍﻨﻔـﻪ )ﻟﻘـﺩ‬ ‫ﺸﺎﻫﺩﺕ ﻓﻌﻼ ﺍﺤﺩ ﺍﻟﺯﻤﻼﺀ ﻴﺴﺘﺨﺩﻡ ﺍﻨﻔﻪ ﻋﻠﻰ ﺍﻟﺸﺎﺸﺔ!(.‬ ‫ﺒﻌﺩ ﺫﻟﻙ، ﻻﺤﻅ ﺍﻟﻤﺒﺭﻤﺠﻭﻥ ﺍﻥ ﻨﺴﺒﺔ ﻜﺒﻴﺭﺓ ﻤﻥ ﺸﻴﻔﺭﺍﺕ ﺒﺭﺍﻤﺠﻬﻡ ﻤﻜﺭﺭﺓ ﻭﻗﺩ ﻜﺘﺒﺕ ﻓـﻲ ﻋﺸـﺭﺍﺕ‬ ‫ﺍﻟﻤﺸﺎﺭﻴﻊ، ﻓﻠﻭ ﺍﻤﻌﻨﺕ ﺍﻟﻨﻅﺭ ﻗﻠﻴ ﹰ، ﻟﻭﺠﺩﺕ ﺍﻥ ﻤﻌﻅﻡ ﺘﻁﺒﻴﻘﺎﺕ ‪ Windows‬ﺘﺘﺸﺎﺭﻙ ﺍﻟﻰ ﺤـﺩ ﻜﺒﻴـﺭ ﻓـﻲ‬ ‫ﻼ‬ ‫ﻤﻌﻅﻡ ﻭﻅﺎﺌﻔﻬﺎ ﺍﻟﺸﺎﺌﻌﺔ، ﻟﺫﻟﻙ ﻜﺎﻥ ﻋﻠﻰ ﻤﻁﻭﺭﻱ ﻨﻅﺎﻡ ‪ Windows‬ﺍﻴﺠﺎﺩ ﺤﻠﻭل ﻟﺘﺒﺎﺩل ﺍﻟﺒﻴﺎﻨـﺎﺕ ﻭﻤﺸـﺎﺭﻜﺔ‬ ‫ﺍﻟﺸﻴﻔﺭﺍﺕ ﺒﻴﻥ ﺍﻟﺒﺭﺍﻤﺞ، ﺍﻻ ﺍﻥ ﺘﺤﻘﻴﻕ ﻫﺫﺍ ﺍﻟﻬـﺩﻑ ﺒـﺩﺍ ﻤﺴـﺘﺤﻴﻼ ﻟـﺒﻌﺽ ﺍﻟﻭﻗـﺕ، ﻻﻥ ﺠﻤﻴـﻊ ﺒـﺭﺍﻤﺞ‬ ‫ﹰ‬ ‫‪ Windows‬ﺘﻌﻤل ﻓﻲ ﻤﻨﺎﻁﻕ ﻤﺨﺘﻠﻔﺔ ﻭﻤﺴﺘﻘﻠﺔ ﺒﻬﺎ ﻓﻲ ﺍﻟـﺫﺍﻜﺭﺓ ﺘﺴـﻤﻰ ﻤﺴـﺎﺤﺎﺕ ﺍﻟﻌﻨﻭﻨـﺔ‬ ‫‪Address‬‬ ‫‪ ،Spaces‬ﻟﺫﻟﻙ ﺃﺴﺱ ﻤﻁﻭﺭﻭﺍ ‪ Windows‬ﺍﺴﻠﻭﺒﺎ ﺍﻭ ﺒﺭﻭﺘﻭﻜﻭل ﺒﺭﻤﺠـﻲ ﻴﺴـﻤﺢ ﻟﻠﺘﻁﺒﻴﻘـﺎﺕ ﺒﺎﻟﺘﺨﺎﻁـﺏ‬ ‫ﻓﻴﻤﺎ ﺒﻴﻨﻬﺎ ﺒﻤﻌـﺎﻴﻴﺭ ﻭﻤﻭﺍﺼـﻔﺎﺕ ﻗﻴﺎﺴـﻴﺔ ﺘﺴـﻤﻰ ﺍﻟﺘﺒـﺎﺩل ﺍﻟـﺩﻴﻨﺎﻤﻴﻜﻲ ﻟﻠﺒﻴﺎﻨـﺎﺕ ‪Dynamic Data‬‬ ‫‪.(DDE ) - Exchange‬‬ ‫ﺍﻻ ﺍﻥ ‪ DDE‬ﻜﺎﻨﺕ ﺒﻬﺎ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﻌﻴﻭﺏ ﺍﻟﺘﻲ ﺤﺩﺕ ﺒﺎﻟﻤﺒﺭﻤﺠﻴﻥ ﺇﻟﻰ ﺘﺠﻨـﺏ ﺍﺴـﺘﺨﺩﺍﻤﻬﺎ، ﻜﻜﺜـﺭﺓ‬ ‫ﺍﻻﻨﻬﻴﺎﺭﺍﺕ ﺍﻟﺘﻲ ﺘﺤﺩﺙ ﻓﻲ ﺍﻟﺒﺭﺍﻤﺞ، ﻭﺍﻻﺘﺼﺎﻻﺕ ﺩﺍﺌﻤﺔ ﺍﻻﻨﻘﻁﺎﻉ ﺒﻴﻥ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ، ﺒﺎﻻﻀـﺎﻓﺔ ﺍﻟـﻰ ﺼـﻌﻭﺒﺔ‬ ‫ﻭﺘﻌﻘﻴﺩﺍﺕ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﻤﺼﺩﺭﻴﺔ ﻭﻏﻴﺭﻫﺎ، ﺇﻟﻰ ﺍﻥ ﻗﺎﻤﺕ ‪ Microsoft‬ﺒﺎﺼﺩﺍﺭ ﺘﻘﻨﻴﺔ ﺭﺒﻁ ﺍﻟﻜﺎﺌﻨﺎﺕ ﻭﺘﻀـﻤﻴﻨﻬﺎ‬ ‫‪ (OLE ) - Object Linking & Embedding‬ﻭﺍﻟﺘﻲ ﺘﻌﺘﻤﺩ ﻓﻲ ﺒﻨﻴﺘﻬﺎ ﺍﻟﺘﺤﺘﻴﺔ ﻋﻠﻰ ‪ ،DDE‬ﺤﻴـﺙ‬ ‫ﻭﻓﺭﺕ ﻗﺎﺒﻠﻴﺔ ﻟﺘﺒﺎﺩل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﻴﻥ ﺍﻟﺒﺭﺍﻤﺞ ﻭﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﺍﻟﻤﺨﺘﻠﻔﺔ ﻟﺘﻤﻜﻨﻙ ﻤﻥ ﺍﺩﺭﺍﺝ ﺠـﺩﻭل ﻤـﻥ‬ ‫‪Microsoft‬‬ ‫‪ Excel‬ﻟﺘﻀﻤﻴﻨﻪ ﺍﻭ ﺭﺒﻁﻪ ﻓﻲ ﻤﺴﺘﻨﺩ ‪.Microsoft Word‬‬ ‫ﻓﻲ ﺍﻭﺍﺨﺭ ﻋﺎﻡ 3991 ﻏﻴﺭﺕ ‪ Microsoft‬ﺍﻟﺒﻨﻴﺔ ﺍﻟﺘﺤﺘﻴﺔ ﻟـ ‪ OLE‬ﺤﻴـﺙ ﻟـﻡ ﺘﻌـﺩ ﺘﻌﺘﻤـﺩ ﻋﻠـﻰ‬ ‫‪ DDE‬ﻭﺘﻡ ﺍﻋﺎﺩﺓ ﺒﻨﺎﺌﻬﺎ ﻤﻥ ﺠﺩﻴﺩ ﻟﺘﺼﺩﺭ ﻤﺎ ﺴﻤﻲ 2‪ ،OLE‬ﻭﺍﻟﺘﻲ ﻤﻜﻨﺕ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﻤـﻥ ﺘﻁﺒﻴـﻕ ﺍﺴـﻠﻭﺏ‬ ‫ﺍﻟﻌﻤل ﻓﻲ ﻨﻔﺱ ﺍﻟﻤﻜﺎﻥ ‪ In-place Activation‬ﺒﺤﻴﺙ ﻴﻤﻜﻨﻙ ﺘﺤﺭﻴﺭ ﺠﺩﻭل ‪ Excel‬ﻭﺍﻨﺕ ﻓـﻲ ﺩﺍﺨـل‬ ‫ﻤﺴﺘﻨﺩ ‪ Word‬ﻓﻲ ﻨﻔﺱ ﺍﻟﻨﺎﻓﺫﺓ ﻭﺩﻭﻥ ﺍﻟﺤﺎﺠﺔ ﻟﻤﻐﺎﺩﺭﺓ ‪.Word‬‬
  • 33.
    ‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮفﻋﻠﻰ ‪V isual Basic .NET‬‬ ‫7‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫اﻟﺤﻠﻢ اﺻﺒﺢ ﺣﻘﻴﻘﺔ ﻣﻊ ‪COM‬‬ ‫ﻤﻥ ﺍﻻﻨﺠﺎﺯﺍﺕ ﺍﻟﺘﻲ ﺍﺤﺩﺜﺕ ﺜﻭﺭﺓ ﻜﺒﻴﺭﺓ ﻓﻲ ﻋـﺎﻟﻡ ﺘﻁـﻭﻴﺭ ﺍﻟﺒـﺭﺍﻤﺞ ﺘﺤـﺕ ‪ ،Windows‬ﺘﻘﻨﻴـﺔ ﺒﺭﻤﺠـﺔ‬ ‫ﺍﻟﻤﻜﻭﻨﺎﺕ ‪ ،(COM) - Component Object Model‬ﺤﻴﺙ ﻤﻜﻨﺕ ﻫﺫﻩ ﺍﻟﺘﻘﻨﻴﺔ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ –ﺒﻠﻐـﺎﺕ‬ ‫ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﺨﺘﻠﻔﺔ - ﻤﻥ ﺍﻟﻤﺸﺎﺭﻜﺔ ﻓﻲ ﺘﻁﺒﻴﻘﺎﺘﻬﻡ ﺒﺎﺴﻠﻭﺏ ﻜﺎﺌﻨﻲ ﺍﻟﺘﻭﺠﻪ ‪ .Object Oriented‬ﻟـﻴﺱ ﻫـﺫﺍ‬ ‫ﻓﻘﻁ، ﺒل ﺘﻌﺩﻯ ﺍﻻﻤﺭ ﺫﻟﻙ ﻟﻴﺼل ﺍﻟـﻰ ﺍﻟﻤﻜﻭﻨـﺎﺕ ﺍﻟﻤﻭﺯﻋـﺔ ‪،(DCOM) - Distributed COM‬‬ ‫ﻟﺘﺼﺒﺢ ﻤﻜﻭﻨﺎﺕ ﺍﻟﺒﺭﺍﻤﺞ ﻤﻭﺯﻋﺔ ﻋﻠﻰ ﺍﺠﻬﺯﺓ ﻤﺨﺘﻠﻔﺔ، ﻭﻴﺘﻡ ﺘﺒﺎﺩل ﺍﻟﺒﻴﺎﻨـﺎﺕ ﻋـﻥ ﻁﺭﻴـﻕ ﺸـﺒﻜﺔ ﺍﻻﻨﺘﺭﻨـﺕ‬ ‫ﺒﺸﻜل ﻤﺫﻫل، ﻓﻴﺴﺘﻁﻴﻊ ﺼﺩﻴﻘﻲ ﻓﻲ ﻤﻨﻐﻭﻟﻴﺎ ﻤﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺒﻌﺽ ﺍﺠﺯﺍﺀ ﺒﺭﻨـﺎﻤﺠﻲ ﺍﻟﻤﻭﺠـﻭﺩ ﻓـﻲ ﺠﻬـﺎﺯﻱ‬ ‫ﺍﻟﻤﺤﻤﻭل ﺍﻟﺫﻱ ﺍﺼﻁﺤﺒﻪ ﻤﻌﻲ ﻓﻲ ﺭﺤﻼﺘﻲ ﺍﻟﺒﺭﻴﺔ ﺒﺼﺤﺭﺍﺀ ﺍﻟﺭﺒﻊ ﺍﻟﺨﺎﻟﻲ.‬ ‫ﺍﺜﺭﺕ ‪ COM‬ﺒﺸﻜل ﺍﻴﺠﺎﺒﻲ ﻜﺒﻴﺭ ﻓﻲ ﻋﺎﻟﻡ ﺘﻁﻭﻴﺭ ﺍﻟﺒـﺭﺍﻤﺞ ﺘﺤـﺕ ‪ ،Windows‬ﻟﺩﺭﺠـﺔ ﻅﻬـﻭﺭ‬ ‫ﺸﺭﻜﺎﺕ ﻤﺘﺨﺼﺼﺔ ﻓﻘﻁ ﻓﻲ ﺘﻁﻭﻴﺭ ﻤﻜﻭﻨـﺎﺕ ‪) COM‬ﻜـﺄﺩﻭﺍ ﺍﻟـﺘﺤﻜﻡ ‪ ،ActiveX Controls‬ﻤﻜﺘﺒـﺎﺕ‬ ‫ﻓﺌﺎﺕ ‪.... ActiveX DLL‬ﺍﻟﺦ(، ﻭﺍﺼﺒﺤﺕ ﻋﻤﻠﻴﺔ ﺒﻨﺎﺀ ﺍﻟﺒﺭﺍﻤﺞ ﺘﻌﺘﻤﺩ ﻋﻠـﻰ ﺍﻟﺒﺭﻤﺠـﺔ ﻤﻜﻭﻨﻴـﺔ ﺍﻟﺘﻭﺠـﻪ‬ ‫‪ Component Oriented Programming‬ﺒﺸـﻜل ـﺭ، ﻭﻻ ﺘﻜـﺎﺩ ﺘﺠـﺩ ﺃﻱ ـﺎﻤﺞ ﺍﻵﻥ ﺇﻻ‬ ‫ﺒﺭﻨـ‬ ‫ﻜﺒﻴـ‬ ‫ﻭﻴﺴﺘﺨﺩﻡ ﻤﻜﻭﻨﺎﺕ ‪.COM‬‬ ‫ﻤﻊ ﺫﻟﻙ، ﻓﺈﻥ ﺍﺴﺘﻴﻌﺎﺏ ﺍﻟﺒﻨﻴﺔ ﺍﻟﺘﺤﺘﻴﺔ ﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﻜﻭﻨﺎﺕ ‪ COM‬ﻤﺴﺎﻟﺔ ﺼﻌﺒﺔ ﺠـﺩﺍ، ﻓﻬـﻲ ﺘﺘﻁﻠـﺏ‬ ‫ﺍﻟﺘﻭﻏل ﻓﻲ ﺘﻔﺎﺼﻴل ﻤﻌﻘﺩﺓ ﻻﺴﺘﺨﺩﺍﻡ ﻤﺎ ﻴﺴـﻤﻰ ﺍﻟﻭﺍﺠﻬـﺎﺕ ‪ ،Interfaces‬ﻭﻜﺜـﺭﺓ ﺍﻻﺨﻁـﺎﺀ ﻭﺍﻟﺸـﻭﺍﺌﺏ‬ ‫ﺍﻟﺒﺭﻤﺠﻴﺔ ﺍﺼﺒﺤﺕ ﺍﻤﺭﺍ ﻁﺒﻴﻌﻴﹰ، ﻭﻋﻨﺩ ﺍﻟﺤﺩﻴﺙ ﻋـﻥ ﻤﺼـﺎﺩﺭ ﺍﻟﻨﻅـﺎﻡ ‪ System Resources‬ﻓﺤـﺩﺙ ﻭﻻ‬ ‫ﺎ‬ ‫ﹰ‬ ‫ﺤﺭﺝ، ﻓﻬﻲ ﺘﺴﺘﻬﻠﻙ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﻤﺴﺎﺤﺎﺕ ﺍﻟﻐﻴﺭ ﻤﺴﺘﺨﺩﻤﺔ ﻟﻌﺩﻡ ﺘﻔﺭﻴﻎ ﺍﺠﺯﺍﺀ ﺍﻟﺫﺍﻜﺭﺓ ﻤﻥ ﺍﻟﻜﺎﺌﻨـﺎﺕ ﺍﻟﻤﺸـﺄﺓ،‬ ‫ﺍﻤﺎ ﺒﺴﺒﺏ ﺍﻻﻨﻬﻴﺎﺭﺍﺕ ﺍﻟﻤﻔﺎﺠﺌﺔ ﻟﻠﺒﺭﺍﻤﺞ، ﺍﻭ ﻨﺴﻴﺎﻥ ﺤﺫﻑ ﻤﺅﺸـﺭﺍﺕ ﺍﻟﻜﺎﺌﻨـﺎﺕ ﺍﻟﺘـﻲ ﺍﻨﺸـﺄﻫﺎ ﺃﻭ ﺍﺴـﺘﺨﺩﻤﻬﺎ‬ ‫ﺍﻟﺒﺭﻨﺎﻤﺞ.‬ ‫ﻤﻥ ﻨﺎﺤﻴﺔ ﺍﺨﺭﻯ، ﻓﺈﻥ ﻤﻜﻭﻨﺎﺕ ‪ COM‬ﺘﻌﺘﻤﺩ ﺍﻋﺘﻤـﺎﺩﺍ ﻜﻠﻴـﺎ ﻋﻠـﻰ ﻤﺴـﺠل ﺍﻟﻨﻅـﺎﻡ ‪Windows‬‬ ‫ﹰ‬ ‫ﹰ‬ ‫‪ ،Registry‬ﻭﺍﻱ ﻤﺸﻜﻠﺔ ﺘﺤﺩﺙ ﻓﻲ ﻫﺫﺍ ﺍﻟﻤﺴﺠل ﺘﺅﺜﺭ ﻋﻠﻰ ﺒﺎﻗﻲ ﺍﻟﻤﻜﻭﻨـﺎﺕ ﺍﻟﻤﺜﺒﺘـﺔ ﻓـﻲ ﺍﻟﺠﻬـﺎﺯ، ﻭﻟـﻥ‬ ‫ﺘﺴﺘﻁﻴﻊ ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﺍﻻ ﺒﺎﻋﺎﺩﺓ ﺘﺭﻜﻴﺏ ‪ Reinstall‬ﺍﻟﺒﺭﺍﻤﺞ ﺍﻟﺘﺎﺒﻌﺔ ﻟﻬﺎ. ﻭﻋﻤﻠﻴﺔ ﺘﺭﻜﻴﺏ ﺍﻟﺒـﺭﺍﻤﺞ ﺒﺤـﺩ ﺫﺍﺘﻬـﺎ‬ ‫ﻤﻌﻘﺩﺓ ﺠﺩﺍ، ﺍﺫ ﺘﺘﻁﻠﺏ ﻤﻨﻙ ﻨﺴﺦ ﻤﻠﻔﺎﺕ ﺍﻟﻤﻜﻭﻨﺎﺕ ﻭﻤﻥ ﺜﻡ ﺘﺴﺠﻴﻠﻬﺎ ﻓﻲ ﺍﻟﻤﺴـﺠل ﻭﺍﻋـﺩﺍﺩﻫﺎ ﻭﺍﻟﺘﺤﻘـﻕ ﻤـﻥ‬ ‫ﺍﻻﺼﺩﺍﺭﺍﺕ ﺍﻻﻗﺩﻡ ﻭﻤﻥ ﺜﻡ ﺘﻌﺭﻴﻔﻬﺎ ﻋﻠﻰ ﺍﻟﺸﺒﻜﺔ ﺍﻟﻤﺤﻠﻴﺔ )ﺍﻥ ﻜﺎﻨـﺕ ‪ ،(DCOM‬ﻭﺍﻱ ﺨﻁـﺄ ﻓـﻲ ﻋﻤﻠﻴـﺔ‬ ‫ﺘﺜﺒﻴﺕ ﺍﻟﺒﺭﺍﻤﺞ، ﻴﺅﺩﻱ ﺍﻟﻰ ﺤﺩﻭﺙ ﻜﺎﺭﺜﺔ ﻓﻲ ﺠﻬﺎﺯ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻭﺍﻟﺘـﺄﺜﻴﺭ ﻋﻠـﻰ ﺒـﺎﻗﻲ ﺍﻟﺒـﺭﺍﻤﺞ ﺍﻟﻤﺜﺒﺘـﺔ ﻓـﻲ‬ ‫ﺍﻟﺠﻬﺎﺯ، ﻟﻴﻜﻭﻥ ﺍﻟﺤل ﺍﻟﻭﺤﻴﺩ ﺍﻋﺎﺩﺓ ﺘﻬﻴﺌﺔ ‪ Format‬ﺍﻟﻘﺭﺹ ﺍﻟﺼﻠﺏ. ﻭﻋﻨﺩ ﺍﻟﺤـﺩﻴﺙ ﻋـﻥ ﺍﻟﺘﻭﺍﻓﻘﻴـﺔ، ﻓـﻼ‬ ‫ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﺼﺩﺍﺭﻴﻥ ﻤﺨﺘﻠﻔﻴﻥ ﻟﻨﻔﺱ ﺍﻟﻤﻜﻭﻥ ﺒﺴﺒﺏ ﻤﺸـﻜﻠﺔ ﺘﺴـﻤﻰ ‪ Versioning‬ﻟـﻴﺱ ﻫـﺫﺍ ﻤﺠـﺎل‬ ‫ﺘﻔﺼﻴﻠﻬﺎ.‬ ‫ﺗﺤﺪﻳﺎت اﻻﻧﺘﺮﻧﺖ‬ ‫ﻤﻊ ﻅﻬﻭﺭ ﺍﻻﻨﺘﺭﻨﺕ ﺍﺼﺒﺤﺕ ﻤﺴﺄﻟﺔ ﺘﻜﺎﻤل ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﻤﻊ ﻫﺫﻩ ﺍﻟﺸﺒﻜﺔ ﺍﻤﺭ ﻀﺭﻭﺭﻱ ﺍﻥ ﻟﻡ ﻴﻜـﻥ ﺍﻟﺯﺍﻤـﻲ،‬ ‫ﻓﻌﻤﻠﻴﺎﺕ ﺘﺤﺩﻴﺙ ﺍﻟﺒﺭﺍﻤﺞ ﻭﺘﺒﺎﺩل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻴﻤﺎ ﺒﻴﻨﻬﺎ ﻴﻤﻜﻥ ﺍﻥ ﺘﺨﻔﺽ ﺘﻜﺎﻟﻴﻔﻬﺎ ﻋﻥ ﻁﺭﻴـﻕ ﺍﻻﻨﺘﺭﻨـﺕ، ﺍﻀـﻑ‬ ‫ﺍﻟﻰ ﺫﻟﻙ ﻤﺩﻯ ﺍﻟﺴﻬﻭﻟﺔ ﺍﻟﺘﻲ ﺘﻤﻜﻥ ﻤﺴﺘﺨﺩﻤﻴﻥ ﺍﻟﻜﻤﺒﻴﻭﺘﺭ –ﺤﻭل ﺍﻟﻌـﺎﻟﻡ - ﻤـﻥ ﺍﻟﻭﺼـﻭل ﺍﻟـﻰ ﺍﻟﻤﻌﻠﻭﻤـﺎﺕ‬
  • 34.
    ‫8‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺒﺎﻟﺘﺼﻔﺢ ﻓﻲ ﺍﻟﻤﻭﺍﻗﻊ ﺍﻟﻤﺨﺘﻠﻔﺔ. ﻫﺫﻩ ﺍﻟﺸﺒﻜﺔ ﻟﻡ ﻴﺤﺼﺭ ﻤﺠﺎﻟﻬﺎ ﻓﻲ ﻋﺭﺽ ﺍﻟﻤﻭﺍﻗﻊ ﻓﻘﻁ، ﺒـل ﺘﻌـﺩﻯ ﺍﻻﻤـﺭ‬ ‫ﺍﻜﺜﺭ ﻤﻥ ﺫﻟﻙ ﺍﻟﻰ ﺍﻥ ﻴﺼل ﻟﻤﺴﺘﻭﻯ ﺘﻁﻭﻴﺭ ﺘﻁﺒﻴﻘﺎﺕ ﻭﻴﺏ ﺒﺎﺴـﺘﺨﺩﺍﻡ ﺘﻘﻨﻴـﺎﺕ ﻤﻌﺎﻟﺠـﺔ ﺍﻟﺼـﻔﺤﺎﺕ ﻋﻠـﻰ‬ ‫ﺍﺠﻬﺯﺓ ﺍﻟﺨﻭﺍﺩﻡ ﻜﺘﻘﻨﻴﺔ ‪.(ASP) - Active Server Pages‬‬ ‫ﻤﻊ ﺫﻟﻙ، ﻓﺈﻥ ﺘﻁﻭﻴﺭ ﺍﻟﻨﻅﻡ ﺍﻟﻜﺒﻴﺭﺓ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪ ASP‬ﺍﻤﺭ ﻤﻌﻘﺩ ﺠﺩﺍ، ﻭﻴﺘﻁﻠـﺏ ﻋﺸـﺭﺍﺕ ﺍﻟﺘﻨﻘﻴﺤـﺎﺕ‬ ‫ﻭﺍﻟﺘﻌﺩﻴﻼﺕ ﻟﻠﺼﻔﺤﺔ ﺍﻟﻭﺍﺤﺩﺓ، ﺨﺎﺼﺔ ﺍﻥ ﻋﻠﻤﺕ ﺍﻥ ﺒﺭﻤﺠﺔ ‪ ASP‬ﻟﻴﺴﺕ ﻜﺎﺌﻨﻴﺔ ﺘﻭﺠـﻪ ‪ ،OOP‬ﺤﻴـﺙ ﺍﻨﻬـﺎ‬ ‫ﻜﺎﻨﺕ ﺘﻌﺘﻤﺩ ﻋﻠﻰ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﺼﻐﺭﺓ ‪ VBScript‬ﻟﻜﺘﺎﺒﺔ ﺸﻴﻔﺭﺍﺕ ﺍﻟﺼﻔﺤﺎﺕ.‬ ‫ﺍﻻ ﺍﻥ ﺩﻋﻡ ﺼﻔﺤﺎﺕ ‪ ASP‬ﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﻜﻭﻨﺎﺕ ‪ COM‬ﺍﺩﻯ ﺍﻟـﻰ ﺘﻜﺎﻤـل ﺤﻘﻴﻘـﻲ ﻭﺘﺴـﻬﻴل ﺍﻜﺒـﺭ‬ ‫ﻭﻤﺭﻭﻨﺔ ﺍﻜﺜﺭ ﻓﻲ ﺘﻁﻭﻴﺭ ﺍﻟﻨﻅﻡ –ﺨﺎﺼﺔ ﺍﻟﻜﺒﻴﺭﺓ، ﻟﻴـﺘﻤﻜﻥ ﺍﻟﻤﺴـﺘﺨﺩﻤﻭﻥ ﻤـﻥ ﺘﻁـﻭﻴﺭ ﺘﻁﺒﻴﻘـﺎﺕ ﻤﺘﻌـﺩﺩﺓ‬ ‫ﺍﻟﻁﺒﻘﺎﺕ ‪ nTied Applications‬ﺤﻘﻴﻘﻴﺔ، ﺘﻌﺘﻤﺩ ﻋﻠـﻰ ﻜﺎﺌﻨـﺎﺕ ‪ ADO‬ﻜﺨﻠﻔﻴـﺔ ﺍﻟﻨﻅـﺎﻡ ﻻﺩﺍﺭﺓ ﻗﻭﺍﻋـﺩ‬ ‫ﺍﻟﺒﻴﺎﻨﺎﺕ، ﻭﻤﻜﻭﻨﺎﺕ ‪ COM‬ﻻﺩﺍﺀ ﻭﻅﺎﺌﻑ ﺍﻟﻨﻅـﺎﻡ ﻜﻁﺒﻘـﺔ ﻭﺴـﻁﻰ، ﻭﺼـﻔﺤﺎﺕ ‪ ASP‬ﻟﺘﻤﺜـل ﻭﺍﺠﻬـﺔ‬ ‫ﺍﻟﻤﺴﺘﺨﺩﻤﻴﻥ.‬ ‫ﺍﻨﺘﺸﺭﺕ ﻨﻅﻡ ‪ ASP‬ﺍﻨﺘﺸﺎﺭﺍ ﻜﺒﻴﺭﺍ ﺒﻴﻥ ﺍﻟﻤﻭﺍﻗﻊ ﺍﻟﻌﺎﻟﻤﻴﺔ، ﺍﻻ ﺍﻥ ﺍﻟﻤﺸﻜﻠﺔ ﺍﻟﺘﻲ ﻭﺍﺠﻬﺕ ﻤﻁﻭﺭﻱ ﻨﻅـﻡ‬ ‫ﻭﻴﺏ ﺘﻅﻬﺭ ﻋﻨﺩ ﺘﺒﺎﺩل ﻭﺘﺸﺎﺭﻙ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﻴﻥ ﺍﻟﻤﻭﺍﻗﻊ ﺍﻟﻤﺨﺘﻠﻔﺔ، ﻓﻤﺜﻼ ﻟﻭ ﻜﻨـﺕ ﺘﺼـﻤﻡ ﻤﻭﻗـﻊ ﻟﺒﻴـﻊ ﺍﻟﻤـﺎﺩﺓ‬ ‫ﺍﻟﺨﺎﻡ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻓﻲ ﺍﻨﺘﺎﺝ ﺍﻟﻔﻼﻓل )ﺍﻟﻁﻌﻤﻴﺔ( ﻭﺍﺭﺩﺕ ﻤﻥ ﻫﺫﺍ ﺍﻟﻨﻅﺎﻡ ﺍﻥ ﻴﺴـﺘﻘﺒل ﺍﻟﻁﻠﺒـﺎﺕ ﻤـﻥ ﻤﺨﺘﻠـﻑ‬ ‫ﺍﻟﺩﻭل ﺍﻟﻌﺭﺒﻴﺔ، ﻭﻋﻠﻰ ﺍﻻﺭﺠﺢ ﺴﺘﺘﻡ ﻋﻤﻠﻴﺔ ﺍﻟﺸﺭﺍﺀ ﺒﺎﻟﻌﻤﻠﺔ ﺍﻟﻤﺤﻠﻴﺔ ﻟﻠﺩﻭﻟﺔ، ﺍﻀﻑ ﺍﻟﻰ ﺫﻟﻙ ﻤﺴـﺄﻟﺔ ﺍﻟﺘﺴـﻌﻴﺭ‬ ‫ﺤﻴﺙ ﺍﻨﻬﺎ ﺘﻌﺘﻤﺩ ﺍﻋﺘﻤﺎﺩﺍ ﻜﻠﻴﺎ ﻋﻠﻰ ﺍﻟﻘﻭﺓ ﺍﻟﺸﺭﺍﺌﻴﺔ ﻟﻌﻤﻠﺔ ﺘﻠﻙ ﺍﻟﺩﻭﻟﺔ، ﻭﺴﻭﻕ ﺍﻟﻤﻁـﺎﻋﻡ ﺍﻟﻤﻨﺎﻓﺴـﺔ ﻓـﻲ ﺍﻨﺘـﺎﺝ‬ ‫ﹰ ﹰ‬ ‫ﺴﻨﺩﻭﻴﺘﺸﺎﺕ ﺍﻟﻔﻼﻓل، ﻟﺫﻟﻙ ﻗﺩ ﺘﺤﺘﺎﺝ ﺍﻟﻰ ﺘﺒﺎﺩل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻊ ﻤﻭﺍﻗﻊ ﺍﺨﺭﻯ ﺘﺤﺩﺩ ﻟـﻙ ﺍﻟﺴـﻌﺭ ﺍﻟﻤﻨﺎﺴـﺏ ﻓـﻲ‬ ‫ﻭﻗﺕ ﻤﻌﻴﻥ، ﻭﻤﻭﺍﻗﻊ ﺍﺨﺭﻯ ﺘﻤﻜﻥ ﺍﻟﻤﺴﺘﺨﺩﻤﻴﻥ ﻤﻥ ﻤﺭﺍﻗﺒﺔ ﻋﻤﻠﻴﺎﺕ ﺸﺤﻥ ﺍﻟﻔﻼﻓل ﻭﺒﻴﺎﻥ ﻤﻭﺍﻗﻌﻬﺎ ﺍﻟﺤﺎﻟﻴﺔ.‬ ‫ﺍﻥ ﺍﺭﺩﺕ ﺘﺒﺎﺩل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻊ ﻫﺫﻩ ﺍﻟﻤﻭﺍﻗﻊ ﺒﺸﻜل ﺘﻘﻠﻴﺩﻱ، ﻓﺎﻟﻌﻤﻠﻴﺔ ﺘـﺘﻡ ﺒﺎﺭﺴـﺎل ﺼـﻔﺤﺎﺕ ‪HTML‬‬ ‫ﻤﻥ ﻤﻭﻗﻊ ﺍﻟﻰ ﺍﺨﺭ، ﻭﻋﻠﻴﻙ ﺍﻟﻘﻴﺎﻡ ﺒﺠﻤﻴﻊ ﺍﻟﺨﻁﻭﺍﺕ ﺍﻟﻼﺯﻤﺔ ﻟﺤﺫﻑ ﺍﻟﻭﺴﻭﻡ ‪) Tags‬ﺍﻟﺘـﻲ ﺘﺴـﺘﺨﺩﻡ ﻟﺘﻨﺴـﻴﻕ‬ ‫ﺼﻔﺤﺎﺕ ‪ ،(HTML‬ﻭﻫﺫﻩ ﺒﺤﺩ ﺫﺍﺘﻬﺎ ﻋﻤﻠﻴﺔ ﻤﻌﻘﺩﺓ ﺠﺩﺍ، ﻭﺘﺘﻁﻠﺏ ﺠﻬﺩ ﻭﻭﻗﺕ ﺍﻀﺎﻓﻲ. ﻟﻴﺱ ﻫﺫﺍ ﻓﻘـﻁ، ﺒـل‬ ‫ﺍﻥ ﺍﻱ ﺘﻌﺩﻴل ﺒﺴﻴﻁ ﻓﻲ ﺼﻔﺤﺎﺕ ﺍﺤﺩ ﺍﻟﻤﻭﺍﻗﻊ ﻗﺩ ﻴﺅﺩﻱ ﺍﻟﻰ ﻜﺎﺭﺜﺔ ﻓﻲ ﻋﻤﻠﻴﺔ ﻨﻘل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻋﺩﻡ ﺩﻗﺘﻬـﺎ ﻭﻗـﺩ‬ ‫ﻴﺼل ﺍﻻﻤﺭ ﺍﻥ ﺘﻜﻭﻥ ﺍﻟﻁﻠﺒﻴﺔ ﻓﻼﻓل ﻭﻴﺘﻡ ﺸﺤﻥ ﺴﻨﺩﻭﻴﺘﺸﺎﺕ ﻜﺒﺩﺓ ﺒﻠﺩﻱ!‬ ‫ﻟﺫﻟﻙ ﺍﻋﺘﻤﺩ ﺍﻟﻤﻁﻭﺭﻭﻥ ﻋﻠﻰ ﺘﻘﻨﻴﺔ ‪ (SOAP) – Simple Object Access Protocol‬ﺒﺤﻴـﺙ‬ ‫ﻴﺘﻡ ﻨﻘل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻋﻥ ﻁﺭﻴﻕ ﻟﻐﺔ ‪) XML‬ﻭﻫﻲ ﻟﻐﺔ ﻭﺼﻑ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻟﻴﺱ ﺘﻨﺴﻴﻕ ﺍﻟﺒﻴﺎﻨـﺎﺕ ﻜــ ‪(HTML‬‬ ‫ﻭﺍﺴﺘﺨﺩﺍﻡ ﺒﺭﻭﺘﻭﻜﻭﻻﺕ ﺍﻻﺘﺼﺎل ‪.TCP/IP‬‬ ‫ﻗﺩ ﺘﻜﻭﻥ ﻓﻜﺭﺓ ‪ SOAP‬ﻤﻤﺘﻌﺔ ﺠﺩﺍ، ﻭﻟﻜﻥ -ﻤﻊ ﺍﻻﺴﻑ ﺍﻟﺸﺩﻴﺩ - ﺍﺴﺘﺨﺩﺍﻡ ﻫﺫﻩ ﺍﻟﺘﻘﻨﻴـﺔ ﻤﻌﻘـﺩ ﺠـﺩﺍ،‬ ‫ﻭﻴﺘﻁﻠﺏ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﺨﺒﺭﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ، ﺒﺤﻴﺙ ﺍﻨﺤﺼﺭ ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﻋﻠﻰ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺍﻟﻤﺤﺘـﺭﻓﻴﻥ ﻓﻘـﻁ، ﻜـﺫﻟﻙ‬ ‫ﻜﺜﺭﺓ ﺍﻻﺨﻁﺎﺀ ﻭﺍﻟﺸﻭﺍﺌﺏ ﺍﻟﺒﺭﻤﺠﻴﺔ ‪ Bugs‬ﻓﻲ ﺘﻁﻭﻴﺭ ﻨﻅﻡ ﺘﻌﺘﻤﺩ ﻋﻠﻰ ‪ SOAP‬ﺍﻤﺭ ﻻ ﻤﻔﺭ ﻤﻨﻪ.‬ ‫ﻋﺸﺮات اﻟﺘﻘﻨﻴﺎت ﻻداء اﻟﻮﻇﺎﺋﻒ‬ ‫ﻜﻤﺎ ﺭﺃﻴﺕ ﻓﻲ ﺍﻟﻔﻘﺭﺍﺕ ﺍﻟﺴﺎﺒﻘﺔ، ﻓﺈﻥ ﺘﻁﻭﻴﺭ ﺍﻟﺒﺭﺍﻤﺞ ﻤﺴﺄﻟﺔ ﻤﻌﻘﺩﺓ ﺠﺩﺍ ﻭﺘﺘﻁﻠﺏ ﺩﺭﺍﻴﺔ ﻜﺎﻓﻴﺔ ﻓﻲ ﺍﻟﺘﻌﺎﻤل ﻤـﻊ‬ ‫ﺍﻟﺘﻘﻨﻴﺎﺕ ﺍﻟﻤﺨﺘﻠﻔﺔ، ﻓﻠﻜﻲ ﺘﻁﻭﺭ ﻤﻭﺍﻗﻊ ﻭﻴﺏ ﺩﻴﻨﺎﻤﻴﻜﻴﺔ ﻋﻠﻴﻙ ﺘﻌﻠﻡ ‪) VBScript‬ﺍﻥ ﻜﺎﻨﺕ ﻤﻥ ﺠﻬـﺔ ﺍﻟﻌﻤﻴـل(‬
  • 35.
    ‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮفﻋﻠﻰ ‪V isual Basic .NET‬‬ ‫9‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻭﺘﻌﻠﻡ ‪) ASP‬ﺍﻥ ﻜﺎﻨﺕ ﻤﻥ ﺠﻬﺔ ﺍﻟﺨﺎﺩﻡ(، ﻭﺍﻥ ﺍﺭﺩﺕ ﺒﻨﺎﺀ ﻨﻅﻡ ﻗﻭﺍﻋﺩ ﺒﻴﺎﻨﺎﺕ ﻋﻤﻼﻗـﺔ ﻋﻠﻴـﻙ ﺍﺘﻘـﺎﻥ ﻟﻐـﺎﺕ‬ ‫ﺍﻻﺴﺘﻌﻼﻡ ‪ T-SQL‬ﻟﻠﺤﺼﻭل ﻋﻠﻰ ﺍﻜﺒﺭ ﻗﺩﺭ ﻤﻥ ﺘﺤﺴـﻴﻥ ﻟﻠﻜﻔـﺎﺀﺓ ‪ ،Optimization‬ﻭﺍﻥ ﺍﺭﺩﺕ ﺘﻁـﻭﻴﺭ‬ ‫ﻤﻜﻭﻨﺎﺕ ‪ COM‬ﺒﻔﺎﻋﻠﻴﺔ ﺍﻜﺜﺭ ﻭﺩﻭﻥ ﺤﺩﻭﺩ ﻋﻠﻴﻙ ﺘﻌﻠﻡ ﺍﺤﺩ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﺘﻘﺩﻤـﺔ ﻜــ ++‪،Visual C‬‬ ‫ﻭﺍﻥ ﺍﺭﺩﺕ ﻤﺨﺎﻁﺒﺔ ﺘﻁﺒﻴﻘﺎﺕ ‪ Microsoft Office‬ﺍﻟﺸﻬﻴﺭﺓ ﻓﻼ ﻤﺨﺭﺝ ﻟـﻙ ﺍﻻ ﺒﺎﺴـﺘﺨﺩﺍﻡ ‪ ،VBA‬ﺍﻤـﺎ ﺍﻥ‬ ‫ﺍﺭﺩﺕ ﺘﻁﻭﻴﺭ ﺒﺭﺍﻤﺞ ﺘﻌﻤل ﺘﺤﺕ ﻨﻅﻡ ‪ Windows‬ﺒﺴﻬﻭﻟﺔ ﻭﻜﺴﺭ ﺤـﺎﺠﺯ ﺍﻟﻭﻗـﺕ ﻓﺴـﺘﺠﺩ ﻀـﺎﻟﺘﻙ ﻓـﻲ‬ ‫‪.Visual Basic‬‬ ‫ﻟﻴﺱ ﻫﺫﺍ ﻓﻘﻁ، ﺒل ﺤﺘﻰ ﺍﻟﻭﻅﺎﺌﻑ ﺍﻟﻤﺘﺸﺎﺒﻬﻪ ﺘﻨﺠﺯ ﺒﺘﻘﻨﻴﺎﺕ ﻤﺨﺘﻠﻔـﺔ، ﻓﻠـﺩﻴﻙ ﻤـﺜﻼ ﺍﻟﺘﻘﻨﻴـﺎﺕ ‪،ADO‬‬ ‫‪ ،DAO‬ﻭ‪ RDO‬ﻟﺘﻁﻭﻴﺭ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﺍﻟﻤﻌﺘﻤﺩﺓ ﻋﻠﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ ،Databases‬ﻭﻫﻨـﺎﻙ ﺍﻴﻀـﺎ ﻤﺠﻤﻭﻋـﺔ‬ ‫ﻤﻥ ﺍﻟﺘﻘﻨﻴﺎﺕ ﻜـ ‪ ،DirectX ،GDI‬ﻭ ‪ OpenGL‬ﻟﺘﻁﻭﻴﺭ ﺍﻟﻨﻅﻡ ﺍﻟﺘـﻲ ﺘﻌﺘﻤـﺩ ﻋﻠـﻰ ﺍﻟﺼـﻭﺭ ﻭﺍﻟﺭﺴـﻭﻡ‬ ‫ﺒﻜﺜﺭﺓ.‬ ‫ﻜﺎﻨﺕ ﻫﺫﻩ ﺠﻭﻟﺔ ﺴﺭﻴﻌﺔ ﺤﻭل ﺒﻨﺎﺀ ﺍﻟﺒﺭﺍﻤﺞ ﻓﻲ ﺍﻟﺴﻨﻭﺍﺕ ﺍﻟﺴﺎﺒﻘﺔ، ﺘﺫﻜﺭ ﺍﻥ ﻜﻼﻤـﻲ ﻤﻭﺠـﻪ ﻟﺘﻘﻨﻴـﺎﺕ‬ ‫‪ Microsoft‬ﻓﻘﻁ. ﻭﺍﻥ ﻟﻡ ﺘﻜﻥ ﻟﺩﻴﻙ ﺍﻱ ﻤﻌﺭﻓﺔ ﺒﻤﺎ ﺴﺒﻕ ﺫﻜﺭﻩ ﻤﻥ ﺘﻘﻨﻴﺎﺕ ﺒﺭﻤﺠﻴﺔ، ﻓـﺄﺭﺠﻭ ﺍﻥ ﻻ ﻴﺼـﻴﺒﻙ‬ ‫ﺫﻟﻙ ﺒﺎﻻﺤﺒﺎﻁ، ﺒل ﻋﻠﻰ ﺍﻟﻌﻜﺱ ﻤﻥ ﺫﻟﻙ، ﻴﻤﻜﻨﻙ ﺃﻥ ﺘﻌﺘﺒﺭ ﻨﻔﺴﻙ ﻤﺒﺭﻤﺞ ﻤﺤﻅﻭﻅ ﺠﺩﺍ، ﺤﻴـﺙ ﺴـﺘﺒﺩﺃ ﺤﻴﺎﺘـﻙ‬ ‫ﺍﻟﺠﺩﻴﺩﺓ ﻤﻥ ﺤﻴﺙ ﺍﻨﺘﻬﻰ ﺍﻵﺨﺭﻴﻥ، ﻭﻤﻊ ﺍﺤﺩﺙ ﻭﺍﻓﻀل ﺘﻘﻨﻴﺔ ﺘﺴﺘﺨﺩﻡ ﻟﺘﻁﻭﻴﺭ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﻓـﻲ ﺍﻟﻘـﺭﻥ ﺍﻟﺤـﺎﺩﻱ‬ ‫ﻭﺍﻟﻌﺸﺭﻴﻥ ﻭﻫﻲ ‪.Microsoft .NET‬‬ ‫اﻟﺤﻴﺎة ﺑﻌﺪ ‪.NET‬‬ ‫ﻻ ﺍﺩﻋﻲ ﻫﻨﺎ ﻋﻠﻡ ﺍﻟﻐﻴﺏ ﻭﻭﺼﻑ ﻤﺴﺘﻘﺒل ﺘﻁﻭﻴﺭ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ، ﻭﻟﻜﻥ ﻴﻤﻜﻨﻙ ﺍﻋﺘﺒﺎﺭ ﻤﺎ ﺴﺎﺫﻜﺭﻩ ﻓـﻲ ﺍﻟﻔﻘـﺭﺍﺕ‬ ‫ﺍﻟﺘﺎﻟﻴﺔ ﻋﺭﺽ ﺴﺭﻴﻊ ﻻﺴﺘﺭﺍﺘﻴﺠﻴﺔ ‪ .NET‬ﻭﺒﻴﺎﻥ ﻤﺩﻯ ﺘﺎﺜﻴﺭﻫﺎ ﻋﻠﻰ ﺼﻨﺎﻋﺔ ﺍﻟﺒﺭﻤﺠﻴﺎﺕ.‬ ‫اﻻﺳﺘﻘﻼﻟﻴﺔ ﻋﻦ ﻣﻨﺼﺎت اﻟﻌﻤﻞ‬ ‫ﺍﻜﺘﺏ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻤﺭﺓ ﻭﺍﺤﺩﺓ ﻓﻘﻁ ﻭﺴﻴﺘﻡ ﺘﻨﻔﻴﺫﻩ ﻋﻠﻰ ﻤﺨﺘﻠﻑ ﻤﻨﺼﺎﺕ ﺍﻟﻌﻤل ﺍﻟﻤﺨﺘﻠﻔـﺔ: ﻜـﺎﻻﺠﻬﺯﺓ ﺍﻟﻤﺤﻤﻭﻟـﺔ‬ ‫‪ ،Notebooks‬ﺨﺎﺩﻤـﺎﺕ ‪ ،Servers‬ﻫﻭﺍﺘـﻑ ﺠﻭﺍﻟـﺔ ‪ ،Mobiles‬ﺘﻠﻴﻔﺯﻴﻭﻨـﺎﺕ ﺭﻗﻤﻴـﺔ ‪،Digital TV‬‬ ‫ﺜﻼﺠﺎﺕ، ﻁﺎﺌﺭﺍﺕ، ﺍﺒﻭﺍﺏ ﻜﺭﺍﺝ، ﺴﻴﺎﺭﺍﺕ، ﻭﻜل ﺸﺊ ﺭﻗﻤﻲ ‪ .Digital‬ﻭﺍﻥ ﻜﻨـﺕ ﺸـﺨﺹ ﺘﺴـﻜﻥ ﻓـﻲ‬ ‫ﻤﻨﻁﻘﺔ ﺒﻌﻴﺩﺓ ﻋﻥ ﻋﺎﺌﻠﺘﻙ ﻭﻻ ﺘﺠﻴﺩ ﺍﻟﻁﺒﺦ، ﻓﻴﻤﻜﻨﻙ ﻁﻠﺏ ﺸـﻴﻔﺭﺓ ﻤﺼـﺩﺭﻴﺔ ﻤـﻥ ﺍﻟﻭﺍﻟـﺩﺓ ﻟﻜﺘﺎﺒـﺔ ﺒﺭﻨـﺎﻤﺞ‬ ‫ﻟﺘﺤﻅﻴﺭ ﺍﻟﻜﺒﺴﺔ ﻭﻤﻥ ﺜﻡ ﺘﺭﻜﻴﺒﻪ ﻓﻲ ﺍﻟﻔﺭﻥ )ﺍﻟﺫﻱ ﺴﻴﻜﻭﻥ ﺭﻗﻤﻲ ﻻﺤﻘـﺎ( ﻻﻨﺠـﺎﺯ ﺍﻟﻜﺒﺴـﺔ. ﻭﻫـﺫﺍ ﺒﻔﻀـل‬ ‫ﺍﺴﺘﻘﻼﻟﻴﺔ ﺒﺭﺍﻤﺠﻙ ﻋﻥ ﻤﻨﺼﺎﺕ ﺍﻟﻌﻤل ﺍﻟﺫﻱ ﺘﻘﺩﻤﻪ ‪.NET‬‬ ‫ﺍﻻﺴﺘﻘﻼﻟﻴﺔ ﻋﻥ ﻤﻨﺼﺎﺕ ﺍﻟﻌﻤل ﻻ ﺘﻨﺤﺼﺭ ﺤﻭل ﺍﻟﻌﺘﺎﺩ ‪ Hardware‬ﻓﻘﻁ، ﺒل ﺘﺸـﻤل ﻨﻅـﻡ ﺍﻟﺘﺸـﻐﻴل‬ ‫ﺍﻟﻤﺨﺘﻠﻔﺔ، ﻓﺤﺎﻟﻴﺎ ﺒﺭﺍﻤﺠﻙ ﻴﻤﻜﻨﻬﺎ ﺍﻥ ﺘﻌﻤل ﻋﻠﻰ ﻤﺨﺘﻠﻑ ﺍﺼﺩﺍﺭﺍﺕ ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ‪ ،Windows‬ﻭﻗﺭﻴﺒـﺎ ﻗـﺩ‬ ‫ﻨﺭﻯ ﺍﻥ ﺍﻁﺎﺭ ﻋﻤل ‪ .NET Framework‬ﺴﻴﺩﻋﻡ ﻓﻲ ﺍﻨﻅﻤﺔ ﺍﻟﺘﺸـﻐﻴل ﺍﻻﺨـﺭﻯ ﻜــ ‪ Linux‬ﻭﺤﺘـﻰ‬ ‫‪.Mac‬‬ ‫ﺍﻟﻨﺘﻴﺠﺔ ﺍﻻﻴﺠﺎﺒﻴﺔ ﻤﻥ ﺍﺴﺘﻘﻼﻟﻴﺔ ﺒﺭﺍﻤﺠﻙ ﻋﻥ ﻤﻨﺼﺎﺕ ﺍﻟﻌﻤل ﺘﻘﺘﻀﻲ ﻤﻨﻙ –ﻜﻤﺒﺭﻤﺞ - ﺍﻟﺘﺭﻜﻴـﺯ ﻋﻠـﻰ‬ ‫ﺒﺭﺍﻤﺠﻙ ﻓﻘﻁ ﺒﻐﺽ ﺍﻟﻨﻅﺭ ﻋﻥ ﺍﻟﻌﺎﻟﻡ ﺍﻟﺨﺎﺭﺠﻲ ﺍﻭ ﺍﻟﻤﻜﺎﻥ ﺍﻟﺫﻱ ﺴﻴﺘﻡ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻓﻴﻪ، ﻤﻊ ﺫﻟﻙ ﻗـﺩ ﺘﺴـﺎل‬
  • 36.
    ‫01‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺴﺅﺍل ﺒﺩﻴﻬﻲ ﻭﺘﻘﻭل: ﺍﻥ ﻜﺎﻨﺕ ﺒﺭﺍﻤﺞ ﻤﺴﺘﻘﻠﺔ ﻋﻥ ﻤﻨﺼﺎﺕ ﺍﻟﻌﻤل، ﻓﻜﻴﻑ ﺴـﻴﺘﻡ ﺘﻨﻔﻴـﺫ ﺍﻟﻭﻅـﺎﺌﻑ ﺍﻟﻤﺨﺘﻠﻔـﺔ‬ ‫ﻭﺍﻟﺘﻲ ﻻ ﺘﺘﻭﻓﺭ ﻓﻲ ﻤﻨﺼﺔ ﻋﻤل ﻤﻌﻴﻨﺔ، ﻭﺍﻟﺠﻭﺍﺏ ﺒﻜل ﺒﺴﺎﻁﺔ ﻴﻌﺘﻤﺩ ﻋﻠﻰ ﻨﻭﻋﻴﺔ ﺍﻟﺒﺭﻨـﺎﻤﺞ ﺍﻟـﺫﻱ ﺘﺼـﻤﻤﻪ،‬ ‫ﻓﺒﻜل ﺘﺄﻜﻴﺩ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﻤﺼﺩﺭﻴﺔ ﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﻭﺍﻟﺩﺓ )ﺘﺤﻀﻴﺭ ﺍﻟﻜﺒﺴﺔ( ﻟﻥ ﺘﻘـﻭﻡ ﺒﺘﺸـﻐﻴﻠﻪ ﻓـﻲ ﻏﺴـﺎﻟﺔ ﺍﻟﻤﻼﺒـﺱ‬ ‫)ﺍﻟﺘﻲ ﺴﺘﻜﻭﻥ ﺭﻗﻤﻴﺔ ﺍﻴﻀﺎ(، ﻭﺍﻨﻤﺎ ﻤﻭﺠﻬﻪ ﺍﻟﻰ ﺍﻟﻔﺭﻥ ﺍﻟﺭﻗﻤﻲ. ﻟﺫﻟﻙ ﺍﺭﻴﺩ ﺘﻭﻀﻴﺢ ﺍﻥ ﺍﻟﻤﻘﺼـﺩ ﻤـﻥ ﻗﻀـﻴﺔ‬ ‫ﺍﺴﺘﻘﻼﻟﻴﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻋﻥ ﻤﻨﺼﺎﺕ ﺍﻟﻌﻤل ﻤﻴﺯﺓ ﻤﻥ ﺍﻁﺎﺭ ﻋﻤـل ‪ .NET Framework‬ﻭﻟـﻴﺱ ﻟﻠﻤﺒـﺭﻤﺞ ﺍﻱ‬ ‫ﻋﻼﻗﺔ ﻤﺒﺎﺸﺭﺓ ﺒﻬﺎ، ﻓﻜل ﻤﺎﻫﻭ ﻤﻁﻠﻭﺏ ﻤﻨﻪ ﻜﺘﺎﺒﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻓﻘﻁ ﺒﺤﻴﺙ ﻴﻼﺌﻡ ﺍﻟﺒﻴﺌﺔ ﺍﻟﺘﻲ ﺴﻴﻌﻤل ﺒﻬﺎ.‬ ‫‪ .NET‬ﻧﺴﺨﺔ ﻣﺤﺴﻨﺔ ﻣﻦ ‪COM‬‬ ‫ﻗﺩ ﹸﻔﺎﺠﺄ ﺍﻥ ﺍﺨﺒﺭﺘﻙ ﺍﻥ ﺍﻻﺴﻡ ﺍﻻﺒﺘﺩﺍﺌﻲ ﻟﻤﺸﺭﻭﻉ ‪ .NET‬ﻜﺎﻥ ﻴﺴﻤﻰ 0.2 ‪ ،COM‬ﺍﻱ ﺍﻟﺠﻴـل ﺍﻟﺘـﺎﻟﻲ ﻤـﻥ‬ ‫ﺘ‬ ‫ﺒﺭﻤﺠﺔ ﺍﻟﻤﻜﻭﻨﺎﺕ ‪ ،COM‬ﻭﻫﺫﻩ ﺒﺤﺩ ﺫﺍﺘﻬﺎ ﺤﻘﻴﻘﺔ ﺍﻥ ﺍﺨﺫﺘﻬﺎ ﺒﺸﻜل ﻨﻅﺭﻱ. ﻓﺎﻟﻔﻜﺭﺓ ﻤـﻥ ‪ COM‬ﻭ ‪.NET‬‬ ‫ﺘﻘﺭﻴﺒﺎ ﻤﺘﻁﺎﺒﻘﺔ –ﻨﻅﺭﻴﺎ - ﻤﻥ ﻤﻨﻁﻠﻕ ﺘﻭﺯﻴﻊ ﺍﻟﺸﻴﻔﺭﺍﺕ ﻭﺍﻻﺴﺘﻘﺎﻟﻴﺔ ﺍﻟﺸﺒﻪ ﺘﺎﻤﺔ ﻋـﻥ ﻤﻨﺼـﺎﺕ ﺍﻟﻌﻤـل، ﺍﻻ ﺍﻥ‬ ‫‪ .NET‬ﺘﺨﺘﻠﻑ ﺍﺨﺘﻼﻓﺎ ﺠﻭﻫﺭﻴﺎ ﻜﺒﻴﺭﺍ ﻓﻲ ﺒﻨﻴﺘﻬﺎ ﺍﻟﺘﺤﺘﻴﺔ ﻋﻥ ‪ ،COM‬ﺤﻴـﺙ ﺍﻥ ﺘﻘﻨﻴـﺔ ‪ .NET‬ﺘـﻡ ﺍﻋـﺎﺩﺓ‬ ‫ﹰ‬ ‫ﹰ‬ ‫ﹰ‬ ‫ﺒﻨﺎﺌﻬﺎ ﻤﻥ ﺠﺩﻴﺩ ﻭﻋﻭﻟﺠﺕ ﺍﻟﻌﺸﺭﺍﺕ ﻤﻥ ﺍﻟﻤﺸﺎﻜل ﺍﻟﺘﻲ ﻭﺍﺠﻬﺕ ﻤﺒﺭﻤﺠﻲ ‪ COM‬ﺴﺎﺒﻘﺎ.‬ ‫ﺍﻭل ﻤﺸﻜﻠﺔ ﺍﺒﺘﺩﺍﺌﻴﺔ ﺘﻡ ﺤﻠﻬﺎ ﻫﻲ ﺍﻻﺴﺘﻐﻨﺎﺀ ﻋـﻥ ﻤﺴـﺠل ﺍﻟﻨﻅـﺎﻡ ‪ ،System Registry‬ﺤﻴـﺙ ﺍﻥ‬ ‫ﻤﻜﻭﻨﺎﺕ ‪ .NET‬ﺘﺼل ﺍﻟﻴﻬﺎ ﻭﺘﺴﺘﻌﻠﻡ ﻋﻨﻬﺎ ﻤﺒﺎﺸﺭﺓ ﻋﻥ ﻁﺭﻴﻕ ﻤﻠﻔﺎﺘﻬﺎ، ﺩﻭﻥ ﺍﻟﺤﺎﺠﺔ ﺍﻟـﻰ ﺍﻟﻤـﺭﻭﺭ ﺒﻤﺴـﺠل‬ ‫ﺍﻟﻨﻅﺎﻡ ﻜﻤﺎ ﻜﻨﺎ ﻨﻔﻌل ﺴﺎﺒﻘﺎ ﻤﻊ ‪ ،COM‬ﻭﻫﺫﺍ ﻴﻌﻨﻲ ﺍﻥ ﻋﻤﻠﻴﺔ ﺘﺜﺒﻴـﺕ ﺍﻟﺒـﺭﺍﻤﺞ ﻻ ﺘﺘﻁﻠـﺏ ﺠﻬـﺩ ﺍﻀـﺎﻓﻲ‬ ‫ﻻﻨﺠﺎﺯﻫﺎ، ﻓﻴﻜﻔﻲ ﻨﺴﺦ ﺍﻟﻤﻠﻔﺎﺕ ﻤﻥ ﺍﻟﻘﺭﺹ ﺍﻟﻤﺩﻤﺞ ﺍﻟﻰ ﺍﻟﻘـﺭﺹ ﺍﻟﺼـﻠﺏ ﻭﺴـﻴﻌﻤل ﺍﻟﺒﺭﻨـﺎﻤﺞ ﺩﻭﻥ ﺃﻴـﺔ‬ ‫ﻤﺸﺎﻜل، ﻤﻊ ﺫﻟﻙ ﻗﺩ ﺘﺤﺘﺎﺝ ﺍﻟﻰ ﺒﺭﺍﻤﺞ ﺍﻟﺘﺭﻜﻴﺏ ﻟﺘﻨﻔﻴﺫ ﺒﻌﺽ ﺍﻟﻠﻤﺴﺎﺕ ﺍﻟﺨﻔﻴﻔﺔ )ﻜﻭﻀﻊ ﺍﻟﻤﻠﻔﺎﺕ ﻓـﻲ ﺍﻤﺎﻜﻨﻬـﺎ‬ ‫ﺍﻟﻤﻨﺎﺴﺒﺔ، ﺘﺨﺼﻴﺹ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﻤﻁﻠﻭﺏ ﺘﺜﺒﻴﺘﻬﺎ، ﺍﻋﺩﺍﺩﺍﺕ ﺒﺴﻴﻁﺔ ﻗﺒﻴل ﻋﻤﻠﻴﺔ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ....ﺍﻟﺦ(.‬ ‫ﻭﺒﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﻜﻭﻨﺎﺕ ﺍﻟﻤﻭﺯﻋﺔ ‪ DCOM‬ﻓﻠﻥ ﺘﺤﺘﺎﺝ ﺍﻟﻰ ﺍﻟﻌﺒـﺙ ﻓـﻲ ﻨﻅـﺎﻡ ﺍﻟﺘﺸـﻐﻴل ‪Windows‬‬ ‫ﻭﻤﺤﺘﻭﻴﺎﺕ ﺍﻟﻤﻜﻭﻥ ﻟﺘﺠﺭﻱ ﻋﺸﺭﺍﺕ ﺍﻻﻋﺩﺍﺩﺍﺕ ﺍﻻﻀﺎﻓﻴﺔ ﺤﺘﻰ ﻴـﺘﻡ ﺘﻭﺯﻴﻌـﻪ، ﺍﺫ ﺍﻥ ﻤﻜﻭﻨـﺎﺕ ‪ .NET‬ﻫـﻲ‬ ‫ﻤﻭﺯﻋﺔ ﺒﺤﺩ ﺫﺍﺘﻬﺎ.‬ ‫ﺃﻤﺎ ﻤﺸﻜﻠﺔ ﺍﻟﺘﻭﺍﻓﻘﻴﺔ ‪ Versioning‬ﻓﻠﻥ ﺘﺤﺩﺙ ﺒﻌﺩ ﺍﻻﻥ، ﺤﻴﺙ ﻴﻤﻜﻥ ﺘﺜﺒﻴﺕ ﺍﺼﺩﺍﺭﻴﻥ ﻤﺨﺘﻠﻔـﻴﻥ ﻤـﻥ‬ ‫ﻨﻔﺱ ﺍﻟﻤﻜﻭﻥ ﺩﻭﻥ ﺍﻥ ﻴﺅﺜﺭ ﺍﺤﺩﻫﻤﺎ ﻋﻠﻰ ﺍﻻﺨﺭ.‬ ‫ﻤﻴﺯﺓ ﻋﻅﻴﻤﺔ ﺃﺨﺭﻯ ﻓﻲ ﻤﻜﻭﻨﺎﺕ ‪ .NET‬ﻟﻡ ﺘﻜﻥ ﻤﺩﻋﻭﻤﺔ ﺴﺎﺒﻘﺎ ﻤﻊ ﻤﻜﻭﻨﺎﺕ ‪ COM‬ﻭﻫﻲ ﺍﻟﻭﺭﺍﺜـﺔ‬ ‫‪ ،Inheritance‬ﻓﻤﻜﻭﻨﺎﺕ ‪ COM‬ﻟﻡ ﻴﻜﻥ ﻤﺘﺎﺤﺎ ﺍﺸﺘﻘﺎﻗﻬﺎ ﻭﺭﺍﺜﻴﺎ ﻭﺘﻁﻭﻴﺭ ﻓﺌﺎﺘﻬـﺎ، ﺍﻤـﺎ ﻤﻜﻭﻨـﺎﺕ ‪.NET‬‬ ‫ﹰ‬ ‫ﻓﻠﺩﻴﻙ ﺍﻟﻘﺩﺭﺓ ﺍﻟﻜﺎﻤﻠﺔ ﻻﺸﺘﻘﺎﻕ ﻓﺌﺎﺕ ﺍﻟﻤﻜﻭﻨﺎﺕ ﻭﺭﺍﺜﻴﺎ ﺩﻭﻥ ﺍﻟﺤﺎﺠﺔ ﻟﻠﺤﺼﻭل ﻋﻠﻰ ﺸﻴﻔﺭﺍﺘﻬﺎ ﺍﻟﻤﺼﺩﺭﻴﺔ.‬ ‫ﺼﺤﻴﺢ ﺍﻥ ﻤﻜﻭﻨﺎﺕ ‪ COM‬ﻜﺎﻨﺕ ﺘﺯﻴل ﺤﺎﺠﺯ ﺍﻟﻔﺭﻭﻗﺎﺕ ﺒﻴﻥ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﺨﺘﻠﻔـﺔ، ﺍﻻ ﺍﻥ ﻫـﺫﺍ‬ ‫ﺍﻟﺤﺎﺠﺯ ﻟﻡ ﻴﺘﻡ ﺍﺯﺍﻟﺘﻪ ﺒﺸﻜل ﻜﺎﻤل، ﻓﻤـﺎ ﺯﺍل ﻤﺒﺭﺠـﻭﺍ ﺒﻌـﺽ ﻟﻐـﺎﺕ ﺍﻟﺒﺭﻤﺠـﺔ )ﻜــ ‪(Visual Basic‬‬ ‫ﻴﻭﺍﺠﻬﻭﻥ ﻤﺸﺎﻜل ﻭﺼﻌﻭﺒﺎﺕ ﻓﻲ ﺍﺴﺘﺨﺩﺍﻡ ﺒﻌﺽ ﻤﻜﻭﻨﺎﺕ ‪ COM‬ﺍﻟﻤﻨﺠﺯﺓ ﺒﻠﻐـﺎﺕ ﻤﺘﻘﺩﻤـﺔ ﺍﺨـﺭﻯ )ﻜــ‬ ‫++‪ (Visual C‬ﺨﺎﺼﺔ ﻤﻊ ﺍﻟﻤﻜﻭﻨﺎﺕ ﺍﻟﺘﻲ ﺘﺘﻌﺎﻤل ﻤﻊ ﺍﻨﻭﺍﻉ ﺒﻴﺎﻨﺎﺕ ﻟﻴﺴﺕ ﻤﺩﻋﻭﻤـﺔ ﻓـﻲ ‪Visual Basic‬‬ ‫) ﻜﺎﻟﻤﺅﺸﺭﺍﺕ ‪ Pointers‬ﻤﺜﻼ(، ﻭﻟﻜﻥ ﻤﻊ ﻤﻜﻭﻨﺎﺕ ‪ .NET‬ﺍﻤﺴﺕ ﻜل ﻫﺫﻩ ﺍﻟﺘﻌﺎﺭﻀـﺎﺕ ﻤـﻥ ﺍﻟﻤﺎﻀـﻲ،‬ ‫ﻭﻤﺭﺩ ﺫﻟﻙ ﺍﻥ ﺠﻤﻴﻊ ﻟﻐﺎﺕ ‪ .NET‬ﻤﻭﺤﺩﺓ ﺒﻔﻀل ﻤﻌﺎﻴﻴﺭ ‪ CRL‬ﻜﻤﺎ ﺴﺘﺭﻯ ﻻﺤﻘﺎ.‬
  • 37.
    ‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮفﻋﻠﻰ ‪V isual Basic .NET‬‬ ‫11‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺗﻜﺎﻣﻞ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ‬ ‫ﺠﻤﻴﻊ ﻟﻐﺎﺕ ‪ .NET‬ﻤﺘﻜﺎﻤﻠﺔ ﻓﻴﻤﺎ ﺒﻴﻨﻬﺎ، ﻓﺒﺭﻨﺎﻤﺠﻙ ﺍﻟﻤﺼﻤﻡ ﺒــ ‪ Visual Basic .NET‬ﻴﻤﻜـﻥ ﺍﻀـﺎﻓﺔ‬ ‫ﺒﻌﺽ ﺍﻟﻌﻨﺎﺼﺭ ﻭﺍﻟﺸﻴﻔﺭﺍﺕ ﺍﻟﻤﺼﺩﺭﻴﺔ ﺇﻟﻴﻪ ﻤﻥ ﻟﻐـﺔ ‪ Visual C# .NET‬ﺩﻭﻥ ﺍﻱ ﻤﺸـﺎﻜل، ﺒـل ﻴﻤﻜـﻥ‬ ‫ﻟﻠﻤﺸﺭﻭﻉ ﺍﻟﻭﺍﺤﺩ ﺍﻥ ﻴﺩﻤﺞ ﺸﻴﻔﺭﺍﺕ ﻤﺼﺩﺭﻴﺔ ﻤﻥ ﻟﻐـﺎﺕ ﻤﺘﻌـﺩﺩﺓ ﻤﺜـل: ‪،Java .NET ،Delphi .NET‬‬ ‫‪) Turki .NET ،Visual C++ .NET‬ﺇﻥ ﻭﺠﺩﺕ(، ‪... ،Fortran .NET‬ﺍﻟﺦ ﻭﺫﻟﻙ ﺒﻔﻀـل ﻤﻌـﺎﻴﻴﺭ‬ ‫‪ CRL‬ﺍﻟﺘﻲ ﺘﻭﺤﺩ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ.‬ ‫ﻗﺩ ﺘﺘﺴﺎﺌل ﻭﺘﻘﻭل، ﻤﺎ ﺩﺍﻤﺕ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﺨﺘﻠﻔﺔ ﻤﻭﺤﺩﺓ ﺒﻬﺫﺍ ﺍﻟﺸﻜل ﻓﻤﺎ ﺍﻟﻔﺎﺌﺩﺓ ﻤـﻥ ﺘﻌﻠـﻡ ﺍﻜﺜـﺭ‬ ‫ﻤﻥ ﻟﻐﺔ؟ ﻭﺍﻟﺠﻭﺍﺏ ﻫﻭ ﺍﻨﻪ ﻤﺎ ﺯﺍﻟﺕ ﻜل ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﺘﺤﺘﻭﻱ ﻋﻠﻰ ﺴﻤﺎﺕ ﻭﻤﻤﻴـﺯﺍﺕ ﺨﺎﺼـﺔ ﺒﻬـﺎ، ﻭﺍﻋﻨـﻲ‬ ‫ﺒﻜﻠﻤﺔ ﺨﺎﺼﺔ ﺒﻬﺎ ﻓﻲ ﻫﺫﺍ ﺍﻟﺴﻴﺎﻕ ﻫﻭ ﻋﺩﻡ ﺍﻤﻜﺎﻨﻴﺔ ﺘﻜﺎﻤﻠﻬﺎ ﻤﻊ ﻟﻐﺎﺕ ‪ .NET‬ﺍﻻﺨـﺭﻯ ﺍﻥ ﺘـﻡ ﺘﻔﻌﻴـل ﻫـﺫﻩ‬ ‫ﺍﻟﻤﺯﺍﻴﺎ. ﻤﻥ ﻨﺎﺤﻴﺔ ﺍﺨﺭﻯ، ﺠﻤﻴـﻊ ﻟﻐـﺎﺕ ‪ .NET‬ﻴـﺘﻡ ﺘﺤﻭﻴﻠﻬـﺎ ﺍﻟـﻰ ﻟﻐـﺔ ‪ MSIL‬ﻟﺤﻅـﺔ ﺍﻟﺘﺭﺠﻤـﺔ‬ ‫‪ Compiling‬ﻜﻤﺎ ﺴﺘﺭﻯ ﻻﺤﻘﺎ.‬ ‫ﺧﺪﻣﺎت وﻳﺐ هﻲ ﻣﺴﺘﻘﺒﻞ اﻻﻧﺘﺮﻧﺖ‬ ‫ﻤﻨﺫ ﺍﻥ ﻨﺸﺒﻙ ﺴﻠﻙ ﺍﻟﻬﺎﺘﻑ ﻭﻨﺘﺼل ﺒﺎﻻﻨﺘﺭﻨﺕ، ﻓـﺈﻥ ﻤﻌﻅـﻡ ﻭﻗﺘﻨـﺎ ﻨﻘﻀـﻴﻪ ﻋﻠـﻰ ﺍﻟﻤﺘﺼـﻔﺢ ‪Browser‬‬ ‫ﻟﻠﻭﺼﻭل ﺍﻟﻰ ﺍﻟﻤﻭﺍﻗﻊ ﺍﻟﻤﺨﺘﻠﻔﺔ، ﺍﻟﻔﻌل ﺍﻟﺴﺎﺒﻕ ﺴﻴﻜﻭﻥ ﻤﻥ ﺍﺴﺎﻁﻴﺭ ﺍﻻﻭﻟﻴﻥ ﻓﻲ ﺍﻟﻤﺴﺘﻘﺒل ﺍﻟﻘﺭﻴﺏ، ﻭﺫﻟـﻙ ﺒﻌـﺩ‬ ‫ﺍﻨﺘﺸﺎﺭ ﺨﺩﻤﺎﺕ ﻭﻴﺏ ‪ Web Services‬ﺤﻴﺙ ﺴﺘﻐﻴﺭ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﺴﻠﻭﺏ ﺘﻌﺎﻤﻠﻨﺎ ﻤﻊ ﺸﺒﻜﺔ ﺍﻻﻨﺘﺭﻨـﺕ ﺒﻁـﺭﻕ‬ ‫ﻟﻡ ﺘﺨﻁﺭ ﻋﻠﻰ ﺒﺎل ﺍﻨﺱ ﻭﻻ ﺠﺎﻥ. ﺍﻟﺠﺯﺀ ﺍﻟﺨﺎﻤﺱ ﺒﺭﻤﺠﺔ ﻭﻴﺏ ﻤﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﻴﻘﺩﻡ ﻟﻙ ﺸﺭﺤﺎ ﻭﺍﻓﻴـﺎ ﺤـﻭل‬ ‫ﹰ‬ ‫ﹰ‬ ‫ﺨﺩﻤﺎﺕ ﻭﻴﺏ، ﻭﻟﻜﻥ ﺩﻋﻨﻲ ﻫﻨﺎ ﺍﻋﺭﻑ ﻟﻙ ﻤﺎﻫﻲ ﺨﺩﻤﺔ ﻭﻴﺏ ‪ Web Service‬ﺒﺸﻜل ﺴﺭﻴﻊ.‬ ‫ﺨﺩﻤﺔ ﻭﻴﺏ )ﺘﺴﻤﻰ ﺍﺤﻴﺎﻨﺎ ‪ (XML Web Service‬ﻤﺎﻫﻲ ﺍﻻ ﺒﺭﻨﺎﻤﺞ ﻴﺴـﺘﻘﺒل ﻁﻠﺒـﺎﺕ ‪Requests‬‬ ‫ﻭﻤﻥ ﺜﻡ ﻴﺴﺘﺠﻴﺏ ﻟﻬﺎ ‪ Response‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﺒﺭﻭﺘﻭﻜﻭل ‪ TCP/IP‬ﺘﺤـﺕ ﻤﻌـﺎﻴﻴﺭ ﻟﻐـﺔ ‪ XML‬ﺍﻟﻘﻴﺎﺴـﻴﺔ،‬ ‫ﻭﺒﺫﻟﻙ ﺘﺘﻤﻜﻥ ﻤﻼﻴﻴﻥ ﺍﻟﻤﻭﺍﻗﻊ ﺍﻟﻤﻨﺘﺸﺭﺓ ﺤﻭل ﺍﻟﻌﺎﻟﻡ ﻤـﻥ ﺘﺒـﺎﺩل ﺍﻟﺒﻴﺎﻨـﺎﺕ ﻓﻴﻤـﺎ ﺒﻴﻨﻬـﺎ ﻭﺍﻨﺠـﺎﺯ ﺍﺍﻷﻋﻤـﺎل‬ ‫ﺍﻟﻤﻁﻠﻭﺒﺔ. ﻴﻤﻜﻨﻙ ﺍﻋﺘﺒﺎﺭ ﺨﺩﻤﺎﺕ ﻭﻴﺏ ﻋﻠﻰ ﺍﻨﻬﺎ ﺒﺭﻨﺎﻤﺞ ﻴﺘﺼـل ﺒﺎﻟﻌـﺎﻟﻡ ﺍﻟﺨـﺎﺭﺠﻲ ﻋـﻥ ﻁﺭﻴـﻕ ﺸـﺒﻜﺔ‬ ‫ﺍﻻﻨﺘﺭﻨﺕ ﻤﻤﺎ ﻴﻤﻜﻨﻙ ﻤﻥ ﺍﺭﺴﺎل ﻭﺍﺴﺘﻘﺒﺎل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺼﻴﻐﺔ ‪ XML‬ﺩﻭﻥ ﺍﻥ ﻴﺘﻁﻠﺏ ﺍﻻﻤـﺭ ﻤﻨـﻙ ﺍﻱ ﺨﺒـﺭﺓ‬ ‫ﻓﻲ ﻟﻐﺔ ‪ XML‬ﺍﻭ ﺒﺭﻭﺘﻭﻜﻭﻻﺕ ‪ ،TCP/IP‬ﺤﻴﺙ ﻴﻭﻓﺭ ﻟﻙ ﺍﻁﺎﺭ ﻋﻤل ‪ .NET Framework‬ﻜـل ﻤـﺎ‬ ‫ﺘﺤﺘﺎﺠﻪ ﻟﺘﻁﻭﻴﺭ ﻭﺒﻨﺎﺀ ﺨﺩﻤﺎﺕ ﻭﻴﺏ.‬ ‫ﺴﺘﻨﺘﺸﺭﺨﺩﻤﺎﺕ ﻭﻴﺏ ﺍﻨﺘﺸﺎﺭﺍ ﻻﻤﺜﻴل ﻟﻪ ﻓﻲ ﻤﻭﺍﻗﻊ ﺍﻻﻨﺘﺭﻨﺕ، )ﺴﻨﻭﻓﺭ ﺨﺩﻤﺔ ﻭﻴﺏ ﻓـﻲ ﻤﻭﻗـﻊ ﺸـﺒﻜﺔ‬ ‫ﹰ‬ ‫ﺍﻟﻤﻁﻭﺭﻭﻥ ﺍﻟﻌﺭﺏ ﺒﻤﺸﻴﺌﺔ ﺍﷲ(، ﺒل ﺴﺘﺼل ﺍﻟﻰ ﺘﻐﻴﻴﺭ ﻤﻌﻅﻡ ﺍﻻﻨﻅﻤﺔ ﺍﻟﺤﺎﻟﻴﺔ ﻟﺘﻌﺘﻤـﺩ ﻋﻠـﻰ ﺨـﺩﻤﺎﺕ ﻭﻴـﺏ‬ ‫ﻭﺘﺼﺒﺢ ﻤﺅﺠﺭﺓ، ﻓﻴﻤﻜﻨﻙ ﻤﺜﻼ ﺘﻭﻓﻴﺭ ﺨﺩﻤﺔ ﻭﻴﺏ ﻟﻠﺘﺫﻜﻴﺭ ﺒﺎﻟﻤﻭﺍﻋﻴﺩ، ﺍﻭ ﺨﺩﻤﺔ ﺘﻭﻓﻴﺭ ﺍﺴﻌﺎﺭ ﺍﻟﻌﻤـﻼﺕ ﺍﻟﺘـﻲ‬ ‫ﺘﺤﺩﺙ ﻋﻠﻰ ﻤﺩﺍﺭ ﺍﻟﺴﺎﻋﺔ، ﺍﻭ ﺨﺩﻤﺔ ﺍﻟﺤﺼﻭل ﻋﻠﻰ ﺩﺭﻭﺱ ﻭﻤﻘﺎﻻﺕ ﻤـﻥ ﻤﻭﻗـﻊ ﺍﺨـﺭ، ﺍﻭ ﺨﺩﻤـﺔ ﺒﺤـﺙ‬ ‫ﻜﺨﺩﻤﺔ ‪... Google Search‬ﺍﻟﺦ.‬
  • 38.
    ‫21‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻣﺎذا ﻋﻦ اﻟﻤﺒﺮﻣﺞ اﻟﻌﺮﺑﻲ؟‬ ‫ﺍﻁﺎﺭ ﻋﻤل ‪ .NET Framework‬ﻤﻭﺠﻪ ﺍﻟﻰ ﺠﻤﻴﻊ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺤﻭل ﺍﻟﻌﺎﻟﻡ ﺒـﺎﺨﺘﻼﻑ ﻟﻐـﺎﺘﻬﻡ ﺍﻟﻁﺒﻴﻌﻴـﺔ،‬ ‫ﻭﺍﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ﺍﺤﺩﻯ ﻫﺫﻩ ﺍﻟﻠﻐﺎﺕ، ﻓﺎﻟﻨﺼﻭﺹ ﻤﺜﻼ ﺠﻤﻴﻌﻬﺎ ﺘﺘﺒﻊ ﺍﻟﺘﺭﻤﻴﺯ ‪ UNICODE‬ﻭﺘﻭﺯﻴـ ﻊ ﻤﺤـﺎﺭﻑ‬ ‫ﻟﻭﺤﺎﺕ ﺍﻟﻤﻔﺎﺘﻴﺢ ﺍﻟﻌﺭﺒﻴﺔ ﻤﺄﺨﻭﺫ ﻓﻲ ﻋﻴﻥ ﺍﻻﻋﺘﺒﺎﺭ، ﻜﺫﻟﻙ ﺍﻟﺤﺎل ﻤـﻊ ﻤﻭﺍﺼـﻔﺎﺕ ﺍﻟﺒﻴﺌـﺔ ﻜﺘﻨﺴـﻴﻕ ﺍﻟﻌﻤﻠـﺔ،‬ ‫ﺍﻟﻭﻗﺕ ﻭﺍﻟﺘﺎﺭﻴﺦ، ﺍﻻﺭﻗﺎﻡ، ﻨﻅﺎﻡ ﺍﻟﻔﺭﺯ ...ﺍﻟﺦ، ﻓﻬﻲ ﻤﺩﻋﻭﻤﺔ ﻟﺠﻤﻴﻊ ﺍﻟﺩﻭل ﺍﻟﻌﺭﺒﻴﺔ ﺒﺎﺴـﺘﺜﻨﺎﺀ -ﻤـﻊ ﺍﻻﺴـﻑ‬ ‫ﺍﻟﺸﺩﻴﺩ - ﺍﻟﺴﻭﺩﺍﻥ، ﻓﻠﺴﻁﻴﻥ، ﺠﻴﺒﻭﺘﻲ، ﺍﻟﺼﻭﻤﺎل ﻭﻤﻭﺭﻴﺘﺎﻨﻴﺎ ﻓﻠﻡ ﺍﺠﺩﻫﺎ ﻓﻲ ﺍﺤـﺩ ﺭﻭﺍﺒـﻁ ﻤﺴـﺘﻨﺩﺍﺕ‬ ‫‪.NET‬‬ ‫‪ Documentation‬ﺍﻟﺭﺴﻤﻴﺔ.‬ ‫ﻭﻋﻨﺩ ﺍﻟﺤﺩﻴﺙ ﻋﻥ ﺍﻟﻤﺴﺎﺌل ﺍﻟﺘﻘﻨﻴﺔ ﺍﻻﺨﺭﻯ، ﻓﺘﻘﻨﻴﺔ ﺍﻟﻤﺭﺁﺓ ‪ Mirroring‬ﻤﺩﻋﻭﻤـﺔ ﺒﺸـﻜل ﺠﻴـﺩ ﻓـﻲ‬ ‫ﻨﻤﺎﺫﺝ ‪) Windows Forms‬ﻜﻤﺎ ﺴﺘﺭﻯ ﻓﻲ ﺍﻟﺠﺯﺀ ﺍﻟﺜﺎﻟﺙ ﺘﻁـﻭﻴﺭ ﺘﻁﺒﻴﻘـﺎﺕ ‪ ،(Windows‬ﻭﺒﺎﻟﻨﺴـﺒﺔ‬ ‫ﻟﻠﺘﺎﺭﻴﺦ ﺍﻟﻬﺠﺭﻱ ﻓﻴﻭﻓﺭ ﻟﻙ ﺍﻁﺎﺭ ﻋﻤل ‪ .NET Framework‬ﺍﻟﻔﺌﺔ ‪ HijriCalendarClass‬ﺍﻟﺘﻲ ﺘﻤﻜﻨـﻙ‬ ‫ﻤﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺘﺎﺭﻴﺦ ﺍﻟﻬﺠﺭﻱ ﻓﻲ ﺒﺭﺍﻤﺠﻙ ﻭﺘﻭﻓﺭ ﻟﻙ ﻁﺭﻕ ﻭﺨﺼﺎﺌﺹ ﻟﺘﻌﺩﻴل ﻭﻀـﺒﻁ ﺍﻟﻘﻴﻤـﺔ ﺍﻟﺼـﺤﻴﺤﺔ‬ ‫ﻟﻠﻴﻭﻡ ﻭﺍﻟﺸﻬﺭ.‬ ‫ﺒﺎﺨﺘﺼﺎﺭ، ﻭﻓﺭﺕ ‪ Microsoft‬ﻤﻨﺼﺔ ﺘﻁﻭﻴﺭ ﻗﻭﻴﺔ ﺘﺩﻋﻡ ﺍﻟﻠﻐـﺔ ﺍﻟﻌﺭﺒﻴـﺔ ﺒﺸـﻜل ﺭﺍﺌـﻊ، ﻟﺘﻨﺤﺼـﺭ‬ ‫ﺍﻟﻤﺴﺅﻭﻟﻴﺔ ﻋﻠﻴﻨﺎ ﻨﺤﻥ ﻜﻌﺭﺏ –ﺴﻭﺍﺀ ﻓﻲ ﺸﺭﻜﺎﺕ ﻋﺭﺒﻴﺔ ﺍﻭ ﻤﻁﻭﺭﻭﻥ ﻋﺭﺏ - ﻟﺘﻘﺩﻴﻡ ﻜﺎﻓﺔ ﺍﻟﺤﻠـﻭل ﺍﻟﻔﻌﺎﻟـﺔ‬ ‫ﻟﻠﻤﺴﺘﺨﺩﻡ ﺍﻟﻌﺭﺒﻲ.‬ ‫ﻣﺤﺘﻮﻳﺎت اﻃﺎر اﻟﻌﻤﻞ ‪.NET Framework‬‬ ‫ﻭﺍﻻﻥ ﺴﻴﺘﻤﺤﻭﺭ ﺤﺩﻴﺜﻲ ﺤﻭل ﻤﻌﻤﺎﺭﻴﺔ ﻭﻤﺤﺘﻭﻴﺎﺕ ﺍﻁﺎﺭ ﻋﻤـل ‪ ،.NET Framework‬ﻴﻤﻜﻨﻨـﻲ ﺍﻥ ﺍﻗﺴـﻡ‬ ‫ﻟﻙ ﻤﺤﺘﻭﻴﺎﺘﻪ ﺍﻟﻰ ﺍﻜﺜﺭ ﻤﻥ 01 ﻁﺒﻘﺎﺕ، ﻭﻟﻜﻨﻲ ﻓﻀﻠﺕ ﺘﻘﻠﻴﺹ ﺍﻟﻌﺩﺩ –ﻟﻠﺘﺴـﻬﻴل ﻋﻠﻴـﻙ - ﻜﻤـﺎ ﺘـﺭﻯ ﻓـﻲ‬ ‫)ﺍﻟﺸﻜل 1 -1(:‬ ‫ﺸﻜل 1 -1: ﻤﺤﺘﻭﻴﺎﺕ ﺍﻁﺎﺭ ﻋﻤل ‪.NET Framework‬‬ ‫ﻤﻜﺘﺒﺔ ﻓﺌﺎﺕ ‪) Base Class Library‬ﺘﺴﻤﻰ ﺍﻴﻀﺎ ﻤﻜﺘﺒـﺔ ﻓﺌـﺎﺕ ‪.NET Framework Class‬‬ ‫‪ (Library‬ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﻤﺌﺎﺕ ﺍﻟﻔﺌﺎﺕ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﻋﺸﺭﺍﺕ ﻤﻠﻔﺎﺕ ‪ DLL‬ﺘﻌﺘﺒﺭ ﻜﻨﺯﺍ ﻏﺎﻟﻴـﺎ ﻴﺴـﻴل ﻟـﻪ‬
  • 39.
    ‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮفﻋﻠﻰ ‪V isual Basic .NET‬‬ ‫31‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻟﻌﺎﺏ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺍﻟﺠﺎﺩﻴﻥ، ﺤﻴﺙ ﺘﺤﻭﻱ ﻜل ﻤﺎ ﺘﺤﺘﺎﺠﻪ ﻻﻨﺠـﺎﺯ ﺒﺭﺍﻤﺠـﻙ ﻭﻤﺸـﺎﺭﻴﻌﻙ ﺒـﺩﺀﺍ ﺒﺘﻘـﺩﻴﻡ ﻓﺌـﺎﺕ‬ ‫ﹰ‬ ‫ﻟﻭﺼﻑ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻻﺴﺎﺴـﻴﺔ )ﻜــ ‪ (Integer ،String‬ﺍﻟـﻰ ﺍﺩﺍﺭﺓ ﺨـﺭﺝ ﻭﺩﺨـل ﺍﻟﻤﻠﻔـﺎﺕ ‪I/O File‬‬ ‫‪ ،Processing‬ﻤﺴﺎﺭﺍﺕ ﺍﻟﺘﻨﻔﻴﺫ ‪ ،Threading‬ﺍﻟﺼﻭﺭ ﻭﺍﻟﺭﺴﻭﻡ، ﻨﻤـﺎﺫﺝ ‪ ،Windows Forms‬ﻨﻤـﺎﺫﺝ‬ ‫‪ ،Web Forms‬ﺍﻻﺘﺼﺎل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ ADO .NET‬ﻭﻏﻴﺭﻫﺎ ﺍﻟﻜﺜﻴﺭ.‬ ‫ﺒﺎﻟﻨﺴﺒﺔ ﻟﻠﻐﺔ ﺍﻟﺘﻨﻔﻴﺫ ﺍﻟﻤﺸﺘﺭﻜﺔ ‪ Common Language Runtime‬ﻓﻬﻲ ﻤﻭﺤـﺩﺓ ﻟﻤﻌـﺎﻴﻴﺭ ﺠﻤﻴـﻊ‬ ‫ﻟﻐﺎﺕ ‪ .NET‬ﺍﻻﺨﺭﻯ، ﻜﻤﺎ ﺍﻨﻬﺎ ﺍﻟﻤﺴـﺅﻭﻟﺔ ﻋـﻥ ﻋﻤﻠﻴـﺎﺕ ﺍﺩﺍﺭﺓ ﺍﻟـﺫﺍﻜﺭﺓ ‪،Memory Management‬‬ ‫ﺘﻔﺭﻴﻎ ﻤﺼﺎﺩﺭ ﺍﻟﻨﻅﺎﻡ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪ ،Garbage Collection‬ﺍﺨﻁﺎﺀ ﻭﻗـﺕ ﺍﻟﺘﻨﻔﻴـﺫ ‪Exception Handling‬‬ ‫)ﺴﺄﺘﺤﺩﺙ ﻋﻥ ﻜل ﻤﺎ ﺫﻜﺭﺘﻪ ﻓﻲ ﺍﻟﻔﺼﻭل ﺍﻟﻼﺤﻘﺔ ﻤﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ(.‬ ‫ﺍﺨﻴﺭﺍ، ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ﺍﻟﺫﻱ ﻴﻤﻜﻨﻙ ﻤـﻥ ﺘﺜﺒﻴـﺕ ﺍﻁـﺎﺭ ﻋﻤـل ‪ .NET Framework‬ﻋﻠﻴـﻪ ﻫـﻭ‬ ‫‪ Windows‬ﻓﻘﻁ )ﻟﺤﻅﺔ ﻜﺘﺎﺒﺔ ﻫﺫﻩ ﺍﻟﺴﻁﻭﺭ(، ﻭﻟﻜﻥ ﻗﺩ ﺘﺭﻯ ﻓﻲ ﺍﻟﻘﺭﻴﺏ ﺍﻟﻌﺎﺠـل ﻨﻅـﻡ ﺘﺴـﻐﻴل ﺍﺨـﺭﻯ‬ ‫ﺩﺍﻋﻤﺔ ﻟﻪ.‬ ‫اﻟﺘﺮﺟﻤﺔ ﻋﻠﻰ اﻟﻔﻮر ‪JIT‬‬ ‫ﻤﻥ ﺍﺠﻤل ﺍﻻﺸﻴﺎﺀ ﺍﻟﺘﻲ ﺴﺘﻜﺘﺸﻔﻬﺎ ﻭﺍﻟﺘﻲ ﺘﻌﺘﺒﺭ ﻓﺘﺢ ﻜﺒﻴﺭ -ﻓﻲ ﺭﺃﻴﻲ ﺍﻟﺸﺨﺼﻲ - ﻓﻲ ﻋـﺎﻟﻡ ﺒﺭﻤﺠـﺔ ‪.NET‬‬ ‫ﻫﻭ ﺍﺴﻠﻭﺏ ﺍﻟﺘﺭﺠﻤﺔ ﻋﻠﻰ ﺍﻟﻔﻭﺭ ‪ ،(JIT ) - Just In Time Compiling‬ﻭﻫﻲ ﺘﻘﻨﻴﺔ ﺘﻘﻭﻡ ﺒﺘﺭﺠﻤـﺔ‬ ‫ﺍﻟﺒﺭﻨﺎﻤﺞ ﻋﻨﺩ ﺘﻨﻔﻴﺫﻩ ﺤﻴﺙ ﻴﻨﺘﺞ ﺍﻓﻀل ﺸﻴﻔﺭﺓ ﺘﺘﻨﺎﺴﺏ ﻤﻊ ﺍﻟﺠﻬﺎﺯ ﺍﻟﺫﻱ ﺴﻴﻌﻤل ﻋﻠﻴﻪ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻤﻤﺎ ﻴﻨـﺘﺞ ﻋﻨـﻪ‬ ‫ﻨﺘﺎﺌﺞ ﺍﻴﺠﺎﺒﻴﺔ ﺠﻴﺩﺓ ﺠﺩﺍ، ﻫﺫﺍ ﻋﻨﺩ ﺍﻟﺤﺩﻴﺙ ﻋﻥ ﺘﺤﺴﻴﻥ ﺍﻟﻜﻔﺎﺀﺓ ‪ ،Optimization‬ﻭﺤﺘﻰ ﺘﻌﻠـﻡ ﻜﻴـﻑ ﻴﺤـﺩﺙ‬ ‫ﺫﻟﻙ ﺘﺎﺒﻊ )ﺍﻟﺸﻜل 1 -2(:‬ ‫ﺸﻜل 1 -2: ﻤﺭﺍﺤل ﺘﺭﺠﻤﺔ ﻭﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ.‬ ‫ﺍﺨﺘﺭ ﺍﻱ ﻟﻐﺔ ﺘﻨﺎﺴﺏ ﻤﺯﺍﺝ ﺍﻨﺎﻤﻠﻙ ﻭﺍﻜﺘﺏ ﺍﻟﺸﻴﻔﺭﺓ ﺒﻬﺎ، ﻭﻋﻨﺩ ﻗﻴﺎﻤﻙ ﺒﻌﻤﻠﻴﺔ ﺍﻟﺘﺭﺠﻤـﺔ ﺴـﻴﺘﻡ ﺘﺤﻭﻴـل‬ ‫ﻤﻠﻑ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﻰ ﻤﻠﻑ ﺸـﺒﻴﻪ ﺒﺎﻟﻤﻠﻔـﺎﺕ ﺍﻟﺘﻨﻔﻴﺫﻴـﺔ ‪ Executable File‬ﻤﻜﺘـﻭﺏ ﺒﻠﻐـﺔ ﺠﺩﻴـﺩﺓ ﺍﺴـﻤﻬﺎ‬
  • 40.
    ‫41‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫‪) Microsoft Intermediate Language‬ﺘﺨﺘﺼـﺭ ‪ IL‬ﺍﻭ ‪ .(MSIL‬ﺤﻴـﺙ ﺘﺤﺘـﻭﻱ ﻋﻠـﻰ ﺸـﻴﻔﺭﺍﺕ‬ ‫ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻟﻜﻨﻬﺎ ﻏﻴﺭ ﻗﺎﺒﻠﺔ ﻟﻠﺘﻨﻔﻴﺫ ﻤﺒﺎﺸﺭﺓ، ﺒل ﻴﺸﺘﺭﻁ ﻭﺠﻭﺩ ﻤﺘﺭﺠﻡ ﻋﻠﻰ ﺍﻟﻔﻭﺭ ‪ JIT‬ﺤﻴـﺙ ﻴﻘـﻭﻡ ﺒﺘﺭﺠﻤـﺔ‬ ‫ﻫﺫﺍ ﺍﻟﻤﻠﻑ ﺍﻟﺜﻨﺎﺌﻲ ﺍﻟﻰ ﻟﻐﺔ ﺍﻻﻟﺔ ﻤﻌﻁﻴﺎ ﺍﻓﻀل ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺒﺤﻴﺙ ﺘﻨﺎﺴـﺏ ﺍﻟﺠﻬـﺎﺯ ﺍﻟﺤـﺎﻟﻲ، ﻓﻌﻨـﺩﻤﺎ ﺘﺼـﻤﻡ‬ ‫ﺒﺭﻨﺎﻤﺠﻙ ﻤﺭﺓ ﻭﺍﺤﺩﺓ ﻓﻘﻁ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪ Visual Basic .NET‬ﻓﺎﻋﻠﻡ ﺍﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺴﻴﺴﺘﻔﻴﺩ ﻤﻥ ﻜـل ﻤﺼـﺎﺩﺭ‬ ‫ﺍﻟﻌﺘﺎﺩ ﻭﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ﺍﻟﺫﻱ ﻴﺘﻡ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻓﻴﻪ، ﺍﻱ ﻟﻭ ﺸﻐﻠﺕ ﺒﺭﻨﺎﻤﺞ ﺘﺤﺕ ﺨـﺎﺩﻡ ‪ Server‬ﻴﺤﺘـﻭﻱ ﻋﻠـﻰ‬ ‫2950740528734059 ﻤﻌﺎﻟﺞ ﻓﺜﻕ ﺜﻘﺔ ﺘﺎﻤﺔ ﺍﻥ ﺒﺭﻨﺎﻤﺠﻙ ﺴﻴﺴﺘﻔﻴﺩ ﻤﻥ ﻜل ﻫﺫﻩ ﺍﻟﻤﻌﺎﻟﺠﺎﺕ ﺭﻏﻡ ﺍﻨـﻙ ﻟـﻡ‬ ‫ﺘﻬﺘﻡ ﺒﻬﺫﻩ ﺍﻟﻨﻘﻁﺔ ﻋﻠﻰ ﺍﻷﺭﺠﺢ.‬ ‫ﻋﻤﻠﻴﺔ ﺍﻟﺘﺭﺠﻤﺔ ‪ JIT‬ﺘﻘﻭﻡ ﺒﺘﺭﺠﻤﺔ ﻜل ﺠﺯﺀ ﻤﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻋﻨﺩ ﺍﻟﺤﺎﺠـﺔ ﺍﻱ ﻋﻨـﺩ ﺍﺴـﺘﺩﻋﺎﺀ ﻭﻅﻴﻔـﺔ‬ ‫ﻤﻌﻴﻨﻪ ﻓﻴﻪ، ﻭﻴﻤﻜﻨﻙ ﺘﺭﺠﻤﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻤﻥ ﺍﻭﻟﻪ ﺍﻟﻰ ﺍﺨﺭﻩ ﺍﻴﻀﺎ ﻋﻥ ﻁﺭﻴﻕ ﻤﺘـﺭﺠﻡ ﺍﺨـﺭ ﻴﺴـﻤﻰ ‪Native‬‬ ‫‪) (NGEN) – Image Generator‬ﻴﺴﻤﻰ ﺍﻴﻀﺎ ‪ (Pre-JIT Compiler‬ﻤﻊ ﻤﻌﺭﻓﺔ ﺍﻥ ﺍﻟﺘﺭﺠﻤـﺔ ﺘـﺘﻡ‬ ‫ﻤﺭﺓ ﻭﺍﺤﺩﺓ ﻓﻘﻁ، ﻭﻟﻥ ﻴﺸﻌﺭ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺒﺄﻱ ﺒﻁﺀ ﻓﻲ ﻋﻤﻠﻴﺔ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻋﻨﺩ ﺘﺸـﻐﻴﻠﻪ ﻤـﺭﺓ ﺍﺨـﺭﻯ، ﻓﻘـﺩ‬ ‫ﺘﻤﺕ ﺘﺭﺠﻤﺘﻪ ﺒﺎﻟﺸﻜل ﺍﻟﻤﻨﺎﺴﺏ ﻟﺠﻬﺎﺯﻩ.‬ ‫اﻟﻤﺠﻤﻌﺎت ‪Assemblies‬‬ ‫ﺍﻟﻤﺠﻤﻊ ‪ Assembly‬ﻤﺎ ﻫﻭ ﺍﻻ ﻤﻠﻑ ) ﻗﺩ ﻴﻜﻭﻥ ‪ EXE‬ﺍﻭ ‪ (DLL‬ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﻜل ﺸﺊ ﻴﺘﻌﻠـﻕ ﺒﺎﻟﺒﺭﻨـﺎﻤﺞ‬ ‫ﺴﻭﺍﺀ ﺸﻴﻔﺭﺍﺘﻪ ﺍﻟﻤﺼﺩﺭﻴﺔ ﺒﻌﺩ ﺍﻟﺘﺭﺠﻤﺔ ‪ ،Compiling‬ﺍﻟﺼﻭﺭ ﻭﺍﻟﺭﺴﻭﻡ، ﻤﻠﻔـﺎﺕ ﺍﻟﻤﺼـﺎﺩﺭ‬ ‫‪Resource‬‬ ‫‪ ،Files‬ﺼﻔﺤﺎﺕ ‪ ،HTML‬ﻭﻏﻴﺭﻫﺎ. ﻜل ﻫﺫﻩ ﺍﻟﻌﻨﺎﺼﺭ ﻴﻤﻜﻨﻙ ﺍﻥ ﺘﻀﻌﻬﺎ ﺠﻤﻴﻌﺎ ﻓﻲ ﻤﻠﻑ ﻭﺍﺤﺩ ﻓﻘﻁ.‬ ‫ﻓﻲ ﺍﻏﻠﺏ ﺍﻻﺤﻭﺍل، ﻴﻤﺜل ﺍﻟﻤﺠﻤﻊ ﺒﺭﻨﺎﻤﺞ ﻭﺍﺤﺩ، ﻤـﻊ ﺫﻟـﻙ ﻴﻤﻜـﻥ ﻟﻠﻤﺠﻤﻌـﺎﺕ ‪ Assemblies‬ﺍﻥ‬ ‫ﺘﺤﺘﻭﻱ ﻋﻠﻰ ﻤﺠﻤﻌﺎﺕ ﺍﺨﺭﻯ، ﺍﻱ -ﺒﻌﺒﺎﺭﺓ ﺃﺨﺭﻯ - ﻴﻤﻜﻥ ﻟﺒﺭﻨﺎﻤﺠﻙ ﺍﻥ ﻴﺩﻤﺞ ﻓﻲ ﺩﺍﺨﻠـﻪ ﺒﺭﻨـﺎﻤﺞ ﺁﺨـﺭ -‬ ‫ﻜﻤﺎ ﺴﺘﺭﻯ ﻻﺤﻘﺎ ﻓﻲ ﺍﻟﻔﺼل ﺍﻟﺤﺎﺩﻱ ﻋﺸﺭ ﺍﻟﻤﺠﻤﻌﺎﺕ ‪.Assemblies‬‬ ‫ﺍﺨﻴﺭﺍ، ﻜل ﻤﺎ ﺫﻜﺭﺘﻪ ﻤﻥ ﺠﻤل ﻭﻋﺒﺎﺭﺍﺕ ﻤﺒﻬﻤﺔ ﻓـﻲ ﺍﻟﻔﻘـﺭﺍﺕ ﺍﻟﺴـﺎﺒﻘﺔ، ﺴـﺎﻋﻭﺩ ﻟﻠﺤـﺩﻴﺙ ﻋﻨﻬـﺎ‬ ‫ﺒﺎﻟﺘﻔﺼﻴل ﺍﻟﻤﻤل ﻓﻲ ﺒﺎﻗﻲ ﻓﺼﻭل ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ، ﻓﻠﺴﺕ ﺒﺤﺎﺠﺔ ﻻﻥ ﺘﻜﻭﻥ ﻤﺴﺘﻭﻋﺒﺎ ﻟﻜل ﺸـﺊ ﺍﻵﻥ، ﺍﺫ ﺍﻥ ﻜـل‬ ‫ﻤﺎ ﻜﻨﺕ ﺍﺭﻴﺩﺓ ﺍﻵﻥ ﻫﻭ ﺘﻘﺩﻴﻡ ﺠﻭﻟﺔ ﺴﺭﻴﻌﺔ ﺤﻭل ﻤﺤﺘﻭﻴﺎﺕ ﺍﻁﺎﺭ ﻋﻤل ‪.NET Framework‬‬ ‫ﺑﻴﺌﺔ اﻟﺘﻄﻮﻳﺮ ‪Visual Studio .NET‬‬ ‫ﻗﺩ ﺍﻏﻴﺭ ﺍﻟﻌﺭﻑ ﺍﻟﻤﺘﺒﻊ ﻓﻲ ﻜﺘﺏ ﺍﻟﺒﺭﻤﺠﺔ )ﻭﺍﻟﺘﻲ ﺘﺒﺩﺃ ﺒﺸﺭﺡ ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ ﺒﺎﻟﺘﻔﺼﻴل(، ﻭﻟﻜـﻥ ﻤـﻥ ﻤﻨﻁﻠـﻕ‬ ‫ﺍﻴﻤﺎﻨﻲ ﺍﻟﺸﺩﻴﺩ ﺒﺎﻥ ﺍﻟﺸﺨﺹ –ﺍﻟﺫﻱ ﻴﻘﺭﺃ ﻜﺘﺎﺒﻲ - ﻫﻭ ﻤﺒﺭﻤﺞ ﻭﻟﻴﺱ ﻤﺴﺘﺨﺩﻡ، ﻓﺎﻋﺘﻘـﺩ ﺍﻨـﻪ ﻗـﺩ ﻭﺼـل ﺍﻟـﻰ‬ ‫ﻤﺭﺤﻠﺔ ﺘﻤﻜﻨﻪ ﻤﻥ ﺘﻌﻠﻴﻡ ﻨﻔﺴﻪ ﺫﺍﺘﻴﺎ ﻻﺴﺘﺨﺩﺍﻡ ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ. ﻟﺫﻟﻙ، ﺍﻟﺘﻤﺱ ﻤﻨـﻙ ﺍﻟﻌـﺫﺭ ﺍﻟﺸـﺩﻴﺩ ﻴـﺎ ﻋﺯﻴـﺯﻱ‬ ‫ﺍﻟﻘﺎﺭﺉ ﻓﻲ ﻤﺴﺎﻟﺔ ﺸﺭﺡ ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ، ﻓﻠﻥ ﺘﺠﺩ ﻫﻨﺎ ﺍﻻ ﻋﺭﺽ ﺴﺭﻴﻊ ﻭﻤﺨﺘﺼﺭ ﻟـﺒﻌﺽ ﻤﺤﺘﻭﻴـﺎﺕ ﺍﻟﺒﻴﺌـﺔ.‬ ‫ﻤﻊ ﺫﻟﻙ، ﻗﺩ ﺍﺘﻁﺭﻕ ﻓﻲ ﻓﺼﻭل ﻻﺤﻘﺔ ﺍﻟﻰ ﺘﻔﺼﻴل ﺒﻌﺽ ﺍﻟﻨﻭﺍﻓﺫ ﻤﺘﻰ ﻤﺎ ﺩﻋﺕ ﺍﻟﺤﺎﺠﺔ ﻟﺫﻟﻙ.‬ ‫ﺘﺘﺸﺎﺭﻙ ﻤﻌﻅﻡ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ) ‪Visual C++ ،Visual C#.NET ،Visual Basic .NET‬‬ ‫‪ .NET‬ﻭﻏﻴﺭﻫﺎ( ﻓﻲ ﺒﻴﺌﺔ ﺘﻁﻭﻴﺭ ﻤﺘﻜﺎﻤﻠﺔ ﻤﻥ ‪ Microsoft‬ﺘﺴﻤﻰ ‪ ،Visual Studio. NET‬ﺤﻴﺙ ﺘـﻭﻓﺭ‬ ‫ﻟﻙ ﻜل ﻤﺎ ﺘﺤﺘﺎﺠﻪ ﻤﻥ ﺨﺩﻤﺎﺕ ﻭﺍﺩﻭﺍﺕ ﻓﻲ ﻗﻤﺔ ﺍﻟﺭﻭﻋﺔ ﺘﺴﻬل ﻟﻙ ﺤﻴﺎﺘﻙ ﺍﻟﺒﺭﻤﺠﻴﺔ. ﺸﺭﺡ ﺠﻤﻴـﻊ ﻤﺤﺘﻭﻴـﺎﺕ‬
  • 41.
    ‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮفﻋﻠﻰ ‪V isual Basic .NET‬‬ ‫51‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫‪ Visual Studio .NET‬ﻴﺘﻁﻠﺏ –ﺩﻭﻥ ﻤﺒﺎﻟﻐﺔ - ﻜﺘﺎﺏ ﻜﺎﻤل، ﻭﻗﺩ ﺍﺼﺩﺭﺕ ﺒﺎﻟﻔﻌـل ‪Microsoft Press‬‬ ‫ﻜﺘﺎﺒﺎ ﻴﺸﺭﺡ ﻜل ﺼﻐﻴﺭﺓ ﻭﻜﺒﻴﺭﺓ ﺤﻭل ﻫﺫﻩ ﺍﻟﺒﻴﺌﺔ، ﺍﻤﺎ ﺍﻟﻜﺘﺎﺏ ﺍﻟـﺫﻱ ﺘ ﻘـﺭﺃﻩ ﻓﻬـﻭ ﻴﺘﻌﻠـﻕ ﺒﻠﻐـﺔ ﺍﻟﺒﺭﻤﺠـﺔ‬ ‫‪ Visual Basic .NET‬ﻓﻘﻁ، ﻭﻟﻥ ﺍﺫﻜﺭ ﺍﻻ ﺍﻟﻨﻭﺍﻓﺫ ﻭﺍﻻﺩﻭﺍﺕ ﺍﻟﺘﻲ ﺴﺘﺴﺘﺨﺩﻤﻬﺎ ﺒﺎﺨﺘﺼﺎﺭ ﻫﻨﺎ.‬ ‫ﻧﻮاﻓﺬ ﺑﻴﺌﺔ اﻟﺘﻄﻮﻳ ﺮ‬ ‫ﻋﻨﺩ ﺘﺸﻐﻴل ﺒﻴﺌﺔ ‪ Visual Studio .NET‬ﻻﻭل ﻤﺭﺓ، ﻤﺴﺘﻅﻬﺭ ﻟﻙ ﺍﻟﻨﺎﻓـﺫﺓ ‪) Start Page‬ﺸـﻜل 1 -3(،‬ ‫ﺘﺴﺘﻁﻴﻊ ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﺍﺨﺭ ﻤﺸﺎﺭﻴﻊ ﺘﻡ ﻓﺘﺤﻬﺎ ﺍﻭ ﺍﻨﺸﺎﺀ ﻤﺸﺎﺭﻴﻊ ﺠﺩﻴﺩﺓ ﻋﻥ ﻁﺭﻴﻕ ﻫـﺫﻩ ﺍﻟﻨﺎﻓـﺫﺓ، ﻜﻤـﺎ ﺍﻨـﻙ‬ ‫ﺘﺴﺘﻁﻴﻊ ﺍﻟﻭﺼﻭل ﺍﻟـﻰ ﺍﺨـﺭ ﺍﻻﺨﺒـﺎﺭ ﺍﻟﻤﺘﻌﻠﻘـﺔ ﺒــ ‪ .NET Framework‬ﺒﺎﻟﻀـﻐﻁ ﻋﻠـﻰ ﺍﻟـﺭﺍﺒﻁ‬ ‫‪ Headlines‬ﻭﺫﻟﻙ ﻻﻥ ﺍﻟﻨﺎﻓﺫﺓ ‪ Start Page‬ﻤﺎﻫﻲ ﺍﻻ ﺼﻔﺤﺔ ﻭﻴﺏ ﺘﻘﻠﻴﺩﻴﺔ.‬ ‫ﺸﻜل 1 -3: ﺍﻟﺸﺎﺸﺔ ﺍﻻﻓﺘﺘﺎﺤﻴﺔ ﻟﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ ‪.Visual Studio .NET‬‬ ‫ﻨﺎﻓﺫﺓ ﺍﻟﺨﻴﺎﺭﺍﺕ ‪:Options‬‬ ‫ﺍﺨﺘﻴﺎﺭﻙ ﻟﻼﻤﺭ ‪ Options‬ﻤﻥ ﻗﺎﺌﻤﺔ ‪ Tools‬ﻴﺅﺩﻱ ﺍﻟﻰ ﻅﻬﻭﺭ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ )ﺍﻟﺸﻜل 1 -4(، ﺤﻴـﺙ ﺘﻤﻜﻨـﻙ‬ ‫ﻤﻥ ﺘﺨﺼﻴﺹ ﻭﺍﻋﺩﺍﺩ ﻋﺸﺭﺍﺕ ﺍﻻﻭﻀـﺎﻉ ﻭﺍﻟﺨﻴـﺎﺭﺍﺕ ﻜﺎﻋـﺩﺍﺩﺍﺕ ﺒﻴﺌـﺔ ﺍﻟﺘﻁـﻭﻴﺭ، ﻤﺤـﺭﺭ ﺍﻟﺸـﻴﻔﺭﺍﺕ،‬ ‫ـﺎﺕ ‪ ،Database‬ﺍﻟﺘﻨﻘـﻴﺢ ‪ ،Debugging‬ـﺭﺭ ـﻔﺤﺎﺕ‬ ‫ﻤﺤـ ﺼـ‬ ‫ـﺩ ﺍﻟﺒﻴﺎﻨـ‬ ‫ﺍﻟﻤﺘﺭﺠﻤـﺎﺕ ‪ ،Compilers‬ﻗﻭﺍﻋـ‬ ‫‪ ،HTML‬ﻤﺼﻤﻡ ﻨﻤﺎﺫﺝ ‪ Windows Forms‬ﻭﻏﻴﺭﻫﺎ.‬
  • 42.
    ‫61‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺸﻜل 1 -4: ﻨﺎﻓﺫﺓ ﺍﻟﺨﻴﺎﺭﺍﺕ ‪.Options‬‬ ‫ﻨﺎﻓﺫﺓ ﻋﺭﺽ ﺍﻟﻔﺌﺎﺕ ‪:Class View‬‬ ‫ﺍﻟﻐﺭﺽ ﺍﻟﺭﺌﻴﺴﻲ ﻤﻥ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻫﻭ ﻋﺭﺽ ﻓﺌﺎﺕ ﺍﻟﺒﺭﻨـﺎﻤﺞ ‪ Project Classes‬ﻋﻠـﻰ ﺸـﻜل ﺸـﺠﺭﻱ‬ ‫)ﺍﻟﺸﻜل 1 -5(، ﻤﻊ ﺍﻟﻌﻠﻡ ﺍﻥ ﺍﻟﻔﺌﺎﺕ ﺍﻟﺘﻲ ﺘﻌﺭﺽ ﻓﻲ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻫﻲ ﺍﻟﻔﺌﺎﺕ ﺍﻟﺘـﻲ ﺘﻌﺭﻓﻬـﺎ ﻓـﻲ ﺍﻟﺸـﻴﻔﺭﺓ‬ ‫ﺍﻟﻤﺼﺩﺭﻴﺔ ﻟﻠﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ ﻓﻘﻁ، ﻓﻼ ﺘﺘﻭﻗﻊ ﻅﻬﻭﺭ ﻓﺌﺎﺕ ﻤﻥ ﻤﻜﺘﺒﺎﺕ ﺍﺨﺭﻯ ﻟﻡ ﻴـﺘﻡ ﺘﻀـﻤﻴﻨﻬﺎ ﻓـﻲ ﻨﻔـﺱ‬ ‫ﺍﻟﻤﺸﺭﻭﻉ.‬ ‫ﺸﻜل 1 -5: ﻨﺎﻓﺫﺓ ﻋﺭﺽ ﺍﻟﻔﺌﺎﺕ ‪Class View‬‬ ‫ﺍﻟﻀﻐﻁ ﺍﻟﻤﺯﺩﻭﺝ ﻋﻠﻰ ﻋﻨﺼﺭ ﻤﻥ ﻋﻨﺎﺼﺭ ﻫﺫﻩ ﺍﻟﺸﺠﺭﺓ، ﻴﺅﺩﻱ ﺍﻟﻰ ﻓﺘﺢ ﻨﺎﻓﺫﺓ ﺍﻟﻤﺤﺭﺭ ﻭﻨﻘل ﻤﺅﺸـﺭ ﺍﻟﻜﺘﺎﺒـﺔ‬ ‫‪ Cursor‬ﺍﻟﻰ ﻤﻨﻁﻘﺔ ﺘﻌﺭﻴﻑ ﺍﻟﻔﺌﺔ ﺍﻭ ﺍﻟﻌﻀﻭ ﻓﻲ ﺍﻟﻔﺌﺔ. ﺍﺨﺘﺭ ﺍﻻﻤـﺭ ‪ Class View‬ﻤـﻥ ﻗﺎﺌﻤـﺔ ‪View‬‬ ‫ﻟﻌﺭﺽ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ.‬
  • 43.
    ‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮفﻋﻠﻰ ‪V isual Basic .NET‬‬ ‫71‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻨﺎﻓﺫﺓ ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤل ‪:Solution Explorer‬‬ ‫ﺍﻥ ﻜﺎﻨﺕ ﻨﺎﻓﺫﺓ ﻋﺭﺽ ﺍﻟﻔﺌﺎﺕ ﺍﻟﺴﺎﺒﻘﺔ ﺘﻌﺭﺽ ﻓﺌﺎﺕ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ، ﻓﺎﻥ ﻨﺎﻓﺫﺓ ﻤﺴﺘﻜﺸـﻑ ﺍﻟﺤـل ﺘﻌـﺭﺽ‬ ‫ﻤﻠﻔﺎﺕ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ ﻭﺍﻟﻤﺸﺎﺭﻴﻊ ﺍﻻﺨﺭﻯ )ﺸﻜل 1 -6(. ﺍﺨﺘﺭ ﺍﻻﻤﺭ ‪ Solution Explorer‬ﻤﻥ ﻗﺎﺌﻤـﺔ‬ ‫‪ View‬ﻟﻌﺭﺽ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ.‬ ‫ﺸﻜل 1 -6: ﻨﺎﻓﺫﺓ ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤل ‪Solution Explorer‬‬ ‫ﻓﻲ ﺍﻋﻠﻰ ﺸﺠﺭﺓ ﻤﻠﻔﺎﺕ ﺍﻟﻤﺸﺭﻭﻉ ﺘﻼﺤﻅ ﻭﺠﻭﺩ ﻋﻨﺼﺭ ﺍﻟﻤﺭﺍﺠﻊ ‪ ،References‬ﻴﻘﺼـﺩ ﺒﻬـﺫﻩ ﺍﻟﻤﺭﺍﺠـﻊ:‬ ‫ﺍﻟﻤﻜﺘﺒﺎﺕ ﺍﻟﺨﺎﺭﺠﻴﺔ ﺍﻟﺘﻲ ﺘﺭﻴﺩ ﺘﻀﻤﻴﻨﻬﺎ ﻓﻲ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ ﻭﺍﻟﻭﺼﻭل ﺍﻟـﻰ ﻓﺌﺎﺘﻬـﺎ، ﺍﻨﻘـﺭ ﺒـﺯﺭ ﺍﻟﻔـﺄﺭﺓ‬ ‫ﺍﻻﻴﻤﻥ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ﻭﺍﺨﺘﺭ ﺍﻻﻤﺭ ‪ Add Reference‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻤﻨﺒﺜﻘﺔ، ﻟﺘﻅﻬﺭ ﻟﻙ ﻨﺎﻓـﺫﺓ ﺍﻟﻤﺭﺍﺠـﻊ‬ ‫)ﺸﻜل 1 -7(.‬ ‫ﺸﻜل 1 -7: ﻨﺎﻓﺫﺓ ﺍﻟﻤﺭﺍﺠﻊ ‪.Reference‬‬
  • 44.
    ‫81‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻤﻊ ﺍﻨﻪ ﻴﻤﻜﻨﻙ ﺍﻀﺎﻓﺔ ﺍﻭ ﺤﺫﻑ ﺍﻟﻤﺭﺍﺠﻊ ﻤﻥ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ.‬ ‫ﻨﺎﻓﺫﺓ ﺨﺼﺎﺌﺹ ﺍﻟﻤﺸﺭﻭﻉ ‪:Project Property Pages‬‬ ‫ﻋﻨﺩ ﺍﻟﺒﺩﺀ ﻓﻲ ﺍﻨﺸﺎﺀ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ، ﻴﻨﺼﺢ ﺩﺍﺌﻤﺎ ﺒﺘﻌﺩﻴل ﺍﻋﺩﺍﺩﺍﺕ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻭﻻ ﻋـﻥ ﻁﺭﻴـﻕ ﻫـﺫﻩ ﺍﻟﻨﺎﻓـﺫﺓ،‬ ‫ﺘﺴﺘﻁﻴﻊ ﺍﻟﻭﺼﻭل ﻟﻬﺎ ﺒﺎﻟﻨﻘﺭ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻻﻴﻤﻥ ﻋﻠﻰ ﻋﻨﺼﺭ ﺍﻟﻤﺸﺭﻭﻉ ﻓﻲ ﻨﺎﻓﺫﺓ ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤل )ﺸـﻜل 1 -‬ ‫6( ﻭﻤﻥ ﺜﻡ ﺍﺨﺘﻴﺎﺭ ﺍﻻﻤﺭ ‪ Properties‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻤﻨﺒﺜﻘﺔ ﻟﺘﻅﻬﺭ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ )ﺸـﻜل 1 -8( ﺍﻜﺘـﺏ ﺍﺴـﻡ‬ ‫ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ ﺘﺤﺕ ﺨﺎﻨﺔ ‪.Assembly Name‬‬ ‫ﺸﻜل 1 -8: ﻨﺎﻓﺫﺓ ﺨﺼﺎﺌﺹ ﺍﻟﻤﺸﺭﻭﻉ.‬ ‫ﻨﺎﻓﺫﺓ ﻤﺴﺘﻌﺭﺽ ﺍﻟﻜﺎﺌﻨﺎﺕ:‬ ‫ﺍﺫﺍ ﺍﺭﺩﺕ ﻤﻌﺭﻓﺔ ﺠﻤﻴﻊ ﺍﻟﻔﺌﺎﺕ ﻭﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻭﺍﻻﻋﻀﺎﺀ ﺍﻟﺘﺎﺒﻌﺔ ﻟﻬﺎ ﺴﻭﺍﺀ ﻜﺎﻨـﺕ ﻫـﺫﻩ ﺍﻟﻔﺌـﺎﺕ ﻤﻌﺭﻓـﺔ ﻓـﻲ‬ ‫ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺤـﺎﻟﻲ ﺍﻭ ﻤﻀـﻤﻨﺔ ﻤـﻥ ﻗﺎﺌﻤـﺔ ﺍﻟﻤﺭﺍﺠـﻊ ‪ ،Reference‬ﻓـﺎﺨﺘﺭ ﺍﻻﻤـﺭ ‪View->Other‬‬ ‫‪ Windows->Object Browser‬ﻟﻌﺭﺽ ﻨﺎﻓﺫﺓ ﻤﺴﺘﻌﺭﺽ ﺍﻟﻜﺎﺌﻨﺎﺕ )ﺍﻟﺸﻜل 1 -9(‬
  • 45.
    ‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮفﻋﻠﻰ ‪V isual Basic .NET‬‬ ‫91‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺸﻜل 1 -9: ﻨﺎﻓﺫﺓ ﻤﺴﺘﻜﺸﻑ ﺍﻟﻜﺎﺌﻨﺎﺕ.‬ ‫ﻨﺎﻓﺫﺓ ﻤﺤﺭﺭ ﺍﻟﺸﻴﻔﺭﺓ ‪:Code Editor‬‬ ‫ﺘﻭﻓﺭ ﻨﺎﻓﺫﺓ ﻤﺤﺭﺭ ﺍﻟﺸﻴﻔﺭﺓ )ﺍﻟﺸﻜل 1 -01( ﻗﺎﺌﻤﺔ ‪ IntelliSense‬ﻭﺍﻟﺘﻲ ﺘﻅﻬﺭ ﺒﻤﺠـﺭﺩ ﻜﺘﺎﺒـﺔ ﺍﻟﻨﻘﻁـﺔ "."‬ ‫ﺒﻌﺩ ﺍﺴﻡ ﺍﻟﻜﺎﺌﻥ ﻟﺘﻌﺭﺽ ﺠﻤﻴﻊ ﺍﻋﻀﺎﺌﻪ، ﻜﻤﺎ ﺘﻭﺠﺩ ﻓﻲ ﺍﻋﻠﻰ ﻨﺎﻓﺫﺓ ﺍﻟﻤﺤﺭﺭ ﻗﺎﺌﻤﺘﻴﻥ ﺍﻻﻭﻟـﻰ ﻟﻨﻘـل ﺍﻟﻤﺅﺸـﺭ‬ ‫ﺍﻟﻰ ﺍﻟﻔﺌﺎﺕ ﻭﺍﻟﻭﺤﺩﺍﺕ ﺍﻟﺒﺭﻤﺠﻴﺔ ﻓﻲ ﺍﻟﻤﻠﻑ ﺍﻟﺤﺎﻟﻲ، ﻭﺍﻟﺜﺎﻨﻴﺔ ﻟﻠﻁﺭﻕ ﻭﺍﻟﺨﺼـﺎﺌﺹ. ﺍﻟﻤﺯﻴـﺩ ﺍﻴﻀـﺎ، ﻴﻤﻜـﻥ‬ ‫ﺍﺨﻔﺎﺀ ﺠﺯﺀ ﻤﻥ ﺍﻟﺸﻴﻔﺭﺍﺕ ﺍﻟﻤﺼﺩﺭﻴﺔ ﻭﺍﻅﻬﺎﺭﻩ ﺒﺎﻟﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺭﻤﻭﺯ "+" ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﻴﺴﺎﺭ ﺍﻟﻨﺎﻓﺫﺓ.‬ ‫ﺸﻜل 1 -01: ﻨﺎﻓﺫﺓ ﻤﺤﺭﺭ ﺍﻟﺸﻴﻔﺭﺓ.‬
  • 46.
    ‫02‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻴﻤﻜﻨﻙ ﺘﺨﺼﻴﺹ ﻭﺘﻐﻴﻴﺭ ﺍﻋﺩﺍﺩﺍﺕ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ )ﻜﺎﻟﺨﻁﻭﻁ، ﺍﻻﻟﻭﺍﻥ، ﺍﻟﻤﺤﺎﺫﺍﺓ ....ﺍﻟﺦ( ﺒﺎﻻﻨﺘﻘـﺎل ﺍﻟـﻰ ﺨﺎﻨـﺔ‬ ‫ﺍﻟﺘﺒﻭﻴﺏ ‪ Text Editor‬ﻓﻲ ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ‪) Option‬ﺸﻜل 1 -4(.‬ ‫اﻟﻘﺎﺋﻤﺔ اﻟﺮﺋﻴﺴﺔ‬ ‫ﻓﻴﻤﺎ ﻴﻠﻲ ﻋﺭﺽ ﺴﺭﻴﻊ ﻟﻤﺤﺘﻭﻴﺎﺕ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﺭﺌﻴﺴﺔ ﺒﺸﻜل ﻤﺨﺘﺼﺭ.‬ ‫ﺍﻟﻘﺎﺌﻤﺔ ‪:File‬‬ ‫ﻤﻌﻅﻡ ﺍﻭﺍﻤﺭ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﺘﺘﻌﻠﻕ ﺒﻤﻠﻔﺎﺕ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ، ﺤﻴﺙ ﺘﻤﻜﻨـﻙ ﻤـﻥ ﺤﻔﻅﻬـﺎ، ﻓﺘﺤﻬـﺎ، ﺍﻏﻼﻗﻬـﺎ‬ ‫ﻭﺍﻀﺎﻓﺔ ﻋﻨﺎﺼﺭ ﻭﻤﻠﻔﺎﺕ ﺍﺨﺭﻯ ﺍﻀﺎﻓﻴﺔ. ﻜﻤﺎ ﺍﻨﻙ ﺘﺴﺘﻁﻴﻊ ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﻭﻅﺎﺌﻑ ﺍﻟﻁﺒﺎﻋـﺔ ‪ Printing‬ﻋـﻥ‬ ‫ﻁﺭﻴﻕ ﻫﺫﻩ ﺍﻟﻘﺎﺌﻤﺔ.‬ ‫ﺍﻟﻘﺎﺌﻤﺔ ‪:Edit‬‬ ‫ﻋﻤﻠﻴﺎﺕ ﺍﻟﺘﺤﺭﻴﺭ ﻜﺎﻟﻨﺴﺦ ‪ ،Copy‬ﺍﻟﻘﺹ ‪ ،Cut‬ﻭﺍﻟﻠﺼﻕ ‪ Paste‬ﻤﻭﺠﻭﺩﺓ ﻓﻲ ﻫﺫﻩ ﺍﻟﻘﺎﺌﻤﺔ، ﺒﺎﻻﻀـﺎﻓﺔ ﺍﻟـﻰ‬ ‫ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﺩﻭﺍﺕ ﺍﻟﺒﺤﺙ ﻭﻋﻼﻤﺔ ﺍﻟﻤﻼﺤﻅﺎﺕ ‪.Bookmarks‬‬ ‫ﺍﻟﻘﺎﺌﻤﺔ ‪:View‬‬ ‫ﺘﺘﻌﻠﻕ ﺒﺎﻅﻬﺎﺭ ﻭﺍﺨﻔﺎﺀ ﻤﺠﻤﻭﻋﺔ ﻜﺒﻴﺭﺓ ﻤﻥ ﺍﻟﻨﻭﺍﻓﺫ ﻤﺘﻌﺩﺩﺓ ﺍﻟﻭﻅﺎﺌﻑ ﻭﺍﻻﻏﺭﺍﺽ.‬ ‫ﺍﻟﻘﺎﺌﻤﺔ ‪:Project‬‬ ‫ﺘﺘﻌﻠﻕ ﺒﺎﻟﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ ﺤﻴﺙ ﺘﻭﻓﺭ ﺍﻭﺍﻤﺭ ﻻﻀﺎﻓﺔ ﻋﻨﺎﺼﺭ ﻭﻤﻠﻔـﺎﺕ ﺍﺨـﺭﻯ ﻟﻠﻤﺸـﺭﻭﻉ، ﻜﻤـﺎ ﺘﺴـﺘﻁﻴﻊ‬ ‫ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﻨﺎﻓﺫﺓ ﺍﻟﻤﺭﺍﺠﻊ ‪ Reference‬ﺍﻴﻀﺎ ﻤﻥ ﺨﻼل ﻫﺫﻩ ﺍﻟﻘﺎﺌﻤﺔ. ﺒﺎﻟﻨﺴﺒﺔ ﻟﻼﻤـﺭ ‪Set As Startup‬‬ ‫‪ Project‬ﻓﻬﻭ ﻴﺠﻌل ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ ﻫﻭ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻻﺒﺘﺩﺍﺌﻲ، ﻭﺫﻟﻙ ﻓﻲ ﺤﺎﻟﺔ ﻭﺠﻭﺩ ﺍﻜﺜـﺭ ﻤـﻥ ﻤﺸـﺭﻭﻉ‬ ‫‪ Project‬ﻓﻲ ﻨﻔﺱ ﺍﻟﺤل ‪.Solution‬‬ ‫ﺍﻟﻘﺎﺌﻤﺔ ‪:Build‬‬ ‫ﺘﻤﻜﻨﻙ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻤﻥ ﺘﺭﺠﻤﺔ ﺍﻟﻤﺸﺭﻭﻉ ‪ ،Compiling‬ﻭﺒﺎﻟﻨﺴـﺒﺔ ﻟﻼﻤـﺭ ‪Configuration Manager‬‬ ‫ﻓﻬﻭ ﻴﺤﺩﺩ ﺍﻻﻋﺩﺍﺩﺍﺕ ﺍﻟﻤﺴﺒﻘﺔ ﺍﻟﺤﻔﻅ ﻟﻠﻤﺘﺭﺠﻡ.‬ ‫ﺍﻟﻘﺎﺌﻤﺔ ‪:Debug‬‬ ‫ﻟﺤﻅﺔ ﺘﺼﻤﻴﻡ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺘﻜﻭﻥ ﻋﺩﺩ ﻋﻨﺎﺼﺭ ﻫﺫﻩ ﺍﻟﻘﺎﺌﻤﺔ ﻻ ﺘﺘﺠﺎﻭﺯ 9 ﺍﻭﺍﻤﺭ، ﻭﻟﻜﻥ ﻋﻨﺩ ﺍﻟﺘﻨﻔﻴـﺫ ﺴـﻴﻤﺘﺩ ﻫـﺫﺍ‬ ‫ﺍﻟﻌﺩﺩ ﻟﻴﺼل ﺍﻟﻰ 31 ﺍﻤﺭ )ﺒﻌﻀﻬﺎ ﻏﻴﺭ ﻤﻔﻌل(، ﺘﺠﺩ ﺍﻭﺍﻤﺭ ﺍﻟﺘﻨﻔﻴﺫ ﻭﺍﻻﻴﻘﺎﻑ ﺍﻟﻨﻬـﺎﺌﻲ ﻭﺍﻟﻤﺅﻗـﺕ ﻓـﻲ ﻫـﺫﻩ‬ ‫ﺍﻟﻨﺎﻓﺫﺓ، ﻜﻤﺎ ﺘﺤﺘﻭﻱ ﻋﻠﻰ ﺠﻤﻴﻊ ﻭﻅﺎﺌﻑ ﺍﻟﺘﻨﻘﻴﺢ ‪ Debugging‬ﻟﻠﺒﺭﻨﺎﻤﺞ.‬
  • 47.
    ‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮفﻋﻠﻰ ‪V isual Basic .NET‬‬ ‫12‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫اﻧﻈﺮ اﻳﻀﺎ‬ ‫ﻟﻌﺮض ﺑ ﻀﻌﺔ اواﻣﺮ ﻣﻦ هﺬﻩ اﻟﻘﺎﺋﻤـﺔ وادوات اﻟﺘﻨﻘـﻴﺢ، اﻧﺘﻘـﻞ اﻟـﻰ اﻟﻔ ﺼـﻞ‬ ‫اﻟﺴﺎﺑﻊ اآﺘﺸﺎف اﻻﺧﻄﺎء.‬ ‫ﺍﻟﻘﺎﺌﻤﺔ ‪:Tools‬‬ ‫ﺘﺤﺘﻭﻱ ﻋﻠﻰ ﺍﻭﺍﻤﺭ ﺍﻀﺎﻓﻴﺔ ﻤﺨﺘﻠﻔﺔ ﺍﻟﻭﻅﺎﺌﻑ، ﻜﻤﺎ ﻴﻤﻜﻨﻙ ﺠﻌﻠﻬﺎ ﻤﻨﺼﺔ ﻟﺘﺸﻐﻴل ﺒـﺭﺍﻤﺞ ﺍﺨـﺭﻯ ﺘﺴـﺘﺨﺩﻤﻬﺎ‬ ‫ﺒﺸﻜل ﻤﺘﻜﺭﺭ ﻋﻥ ﻁﺭﻴﻕ ﺍﺨﺘﻴﺎﺭ ﺍﻻﻤـﺭ ‪ .Externals Tools‬ﻭﺒﺎﻟﻨﺴـﺒﺔ ﻟﻼﻀـﺎﻓﺎﺕ ‪ ،Add-Ins‬ﻓـﻴﻤﻜﻥ‬ ‫ﺍﻟﻭﺼﻭل ﻟﻬﺎ ﻋﻥ ﻁﺭﻴﻕ ﺍﺨﺘﻴﺎﺭ ﺍﻻﻤﺭ ‪.Add-In Manager‬‬ ‫ﺍﻟﻘﺎﺌﻤﺔ ‪:Window‬‬ ‫ﻻ ﺘﻌﻠﻴﻕ!‬ ‫ﺍﻟﻘﺎﺌﻤﺔ ‪:Help‬‬ ‫ﻻﺒﺩ ﻤﻥ ﺍﻥ ﺘﻜﻭﻥ ﻗﺩ ﺜﺒﺕ ﻨﺴﺨﺔ ﻤﻥ ﻤﻜﺘﺒـﺔ ‪ MSDN‬ﺍﻭ ‪ .NET Documentation‬ﺤﺘـﻰ ﺘـﺘﻤﻜﻥ ﻤـﻥ‬ ‫ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ. ﻭﺒﺎﻟﻨﺴﺒﺔ ﻟﻼﻤﺭ ‪ ،Dynamic Help‬ﻓﻬﻭ ﻴﻌﺭﺽ ﻟﻙ ﻨﺎﻓﺫﺓ ﺘﻅﻬﺭ ﺘﻌﻠﻴﻤـﺎﺕ ﻓﻭﺭﻴـﺔ‬ ‫ﺒﻤﺠﺭﺩ ﺍﻟﻨﻘﺭ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﻋﻠﻰ ﺍﻱ ﻋﻨﺼﺭ ﺍﻭ ﻨﺎﻓﺫﺓ ﻤﻥ ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ. ﺍﻨﺼﺤﻙ ﺒﺎﻏﻼﻕ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻋﻨـﺩ ﻋـﺩﻡ‬ ‫ﺍﻟﺤﺎﺠﺔ ﺇﻟﻴﻬﺎ، ﻓﻬﻲ ﺘﺴﺒﺏ ﺒﻁﺀ ﻨﺴﺒﻲ ﻓﻲ ﺍﻟﺠﻬﺎﺯ ﺨﺎﺼﺔ ﺍﻥ ﻜﺎﻥ ﺠﻬﺎﺯﻙ ﺒﻁﻲﺀ.‬ ‫اﺷﺮﻃﺔ اﻻدوات‬ ‫ﺍﺸﺭﻁﺔ ﺍﻻﺩﻭﺍﺕ ‪ Toolbars‬ﻤﺎ ﻫﻲ ﺍﻻ ﺍﻭﺍﻤﺭ ﻤﺜل ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﺭﺌﻴﺴﻴﺔ ﺘﻘﺭﻴﺒﺎ، ﻴﻤﻜـﻥ ﺍﻀـﺎﻓﺘﻬﺎ‬ ‫ﺘﺤﺭﻴﺭﻫﺎ ﻭﺤﺫﻓﻬﺎ ﺒﺎﻟﻀﻐﻁ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻻﻴﻤﻥ ﻋﻠﻰ ﺍﻱ ﺸﺭﻴﻁ ﻭﺍﺨﺘﻴﺎﺭ ﺍﻻﻤـﺭ ‪ Customize‬ﻤـﻥ ﺍﻟﻘﺎﺌﻤـﺔ‬ ‫ﺍﻟﻤﻨﺒﺜﻘﺔ، ﺘﻤﺎﻤﺎ ﻜﻤﺎ ﺘﻔﻌل ﻤﻊ ﻁﺎﻗﻡ ﺘﻁﺒﻴﻘﺎﺕ ‪.Microsoft Office‬‬ ‫ﹰ‬ ‫آﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺠﻚ اﻻول‬ ‫ﻭﺍﻻﻥ ﺴﻨﺒﺩﺃ ﺒﻜﺘﺎﺒﺔ ﺍﻭل ﺒﺭﻨﺎﻤﺞ ﻟﻙ ﺒﻠﻐﺔ ‪ Visual Basic .NET‬ﺤﺘﻰ ﺘﺘﻤﻜﻥ ﻤﻥ ﺍﺴـﺘﺨﺩﺍﻡ ﺒﻴﺌـﺔ ‪Visual‬‬ ‫‪ Studio .NET‬ﺒﺸﻜل ﻤﺒﺩﺌﻲ.‬ ‫اﻟﺤﻠﻮل واﻟﻤﺸﺎرﻳﻊ‬ ‫ﺍﻟﺤل ‪ Solution‬ﻫﻭ ﻋﺒﺎﺭﺓ ﻋﻥ ﺤﺎﻭﻴﺔ ﻟﻌﻨﺼـﺭ ﺍﻭ ﻤﺠﻤﻭﻋـﺔ ﻋﻨﺎﺼـﺭ ﺘﺴـﻤﻰ ﺍﻟﻤﺸـﺎﺭﻴﻊ ‪،Projects‬‬ ‫ﻭﺍﻟﻤﺸﺭﻭﻉ ﻫﻭ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺫﻱ ﺘﻭﺩ ﺍﻨﺸﺎﺌﻪ ﻭﺍﻟﺫﻱ ﺒﺩﻭﺭﻩ ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﻋﺩﺓ ﻋﻨﺎﺼﺭ ﺘﺴـﻤﻰ ﻤﻠﻔـﺎﺕ ﺍﻟﻤﺸـﺭﻭﻉ‬ ‫‪ Project Files‬ﺍﻭ ﻭﺤﺩﺍﺕ ﺍﻟﻤﺸﺭﻭﻉ ‪.Project Items‬‬
  • 48.
    ‫22‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺴﺄﺒﺩﺃ ﻤﻌﻙ ﺒﺎﻟﺤل ‪ ،Solution‬ﻴﻤﻜﻨﻙ ﺍﻨﺸﺎﺀ ﺤل ﺠﺩﻴﺩ ﺒﺎﺨﺘﻴﺎﺭ ﺍﻻﻤـﺭ ﺍﻟﻔﺭﻋـﻲ ‪Blank Solution‬‬ ‫ﻤﻥ ﺍﻻﻤﺭ ‪ New‬ﻤﻥ ﻗﺎﺌﻤﺔ ‪ File‬ﺤﻴﺙ ﺴﻴﻅﻬﺭ ﻟﻙ ﺼﻨﺩﻭﻕ ﺤﻭﺍﺭ ﺒﻌﻨـﻭﺍﻥ ‪ New Project‬ﻴﻁﻠـﺏ ﻤﻨـﻙ‬ ‫ﺍﺴﻡ ﺍﻟﺤل ﻭﻤﺴﺎﺭ ﻤﺠﻠﺩﻩ. ﺒﻌﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ‪ OK‬ﺴﺘﻨﺸﺊ ﻟﻙ ﺒﻴﺌـﺔ ﺍﻟﺘﻁـﻭﻴﺭ ‪Visual Studio .NET‬‬ ‫ﻤﻠﻔﻴﻥ -ﻓﻲ ﻨﻔﺱ ﺍﻟﻤﺠﻠﺩ ﺍﻟﺫﻱ ﺤﺩﺩﺘﻪ ﺴﺎﺒﻘﺎ - ﺒﺎﻻﻤﺘﺩﺍﺩﻴﻥ ‪ .sln‬ﻭ ‪ .suo‬ﺍﻟﻤﻠﻑ ‪ sln‬ﻫﻭ ﻤﻠـﻑ ﻨﺼـﻲ ﻴﻤﺜـل‬ ‫ﹰ‬ ‫ﻤﺭﺍﺠﻊ ﺍﻟﻰ ﺍﻟﻤﺸﺎﺭﻴﻊ ﺍﻟﻤﻀﻤﻨﺔ ﻓﻲ ﺍﻟﺤل ﺍﻟﺤﺎﻟﻲ، ﺍﻤﺎ ﺍﻟﻤﻠﻑ ‪ suo‬ﻓﻴﺤﺘـﻭﻱ ﻋﻠـﻰ ﺍﻻﻋـﺩﺍﺩﺍﺕ ﻭﺨﻴـﺎﺭﺍﺕ‬ ‫ﺍﻟﺘﺨﺼﻴﺹ ﺍﻟﺘﻲ ﺘﺤﺩﺩﻫﺎ ﻓﻲ ﻫﺫﺍ ﺍﻟﺤل ﻜﻤﻭﺍﻗﻊ ﺍﻟﻨﻭﺍﻓﺫ ﺍﻟﻤﻔﺘﻭﺤﺔ ﻭﻏﻴﺭﻫﺎ.‬ ‫ﺒﻌﺩ ﺍﻨﺸﺎﺌﻙ ﺤل ﺠﺩﻴﺩ ﻗﺩ ﺘﺒﺩﺃ ﺒﺎﻀﺎﻓﺔ ﻤﺸﺭﻭﻉ ﺍﻭ ﻋﺩﺓ ﻤﺸﺎﺭﻴﻊ ﺍﻟﻴﻪ، ﺍﺨﺘﺭ ﺍﻻﻤـﺭ ﺍﻟﻔﺭﻋـﻲ ‪Project‬‬ ‫ﻤﻥ ﺍﻻﻤﺭ ‪ New‬ﻤﻥ ﻗﺎﺌﻤﺔ ‪ File‬ﺴﻴﻅﻬﺭ ﻟﻙ ﻨﻔﺱ ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﺍﻟﺴﺎﺒﻕ، ﺍﻨﻘـﺭ ﻋﻠـﻰ ﺍﻟﻌﻨﺼـﺭ ‪Node‬‬ ‫ﻓﻲ ﺍﻟﺸﺠﺭﺓ ﺍﻟﻴﺴﺭﻯ ﺍﻟﺫﻱ ﻴﺤﻤل ﺍﻻﺴﻡ ‪ Visual Basic Projects‬ﺤﺘﻰ ﺘﻅﻬﺭ ﻟﻙ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻴﻤﻨﻰ ﻋـﺩﺓ‬ ‫ﻗﻭﺍﻟﺏ ‪ Templates‬ﺠﺎﻫﺯﺓ ﻟﻼﺴﺘﺨﺩﺍﻡ. ﺤﺩﺩ ﻨﻭﻉ، ﺍﺴﻡ، ﻭﻤﺴﺎﺭ ﺍﻟﻤﺸﺭﻭﻉ ﺜﻡ ﺘﺄﻜﺩ ﻤـﻥ ﺍﻻﺨﺘﻴـﺎﺭ ‪Add to‬‬ ‫‪ solution‬ﻗﺒل ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ‪) OK‬ﺸﻜل 1 -11(:‬ ‫ﺸﻜل 1 -11: ﺍﻟﻘﻭﺍﻟﺏ ‪ Templates‬ﺍﻟﺠﺎﻫﺯﺓ ﻭﺍﻟﺘﻲ ﺘﻤﺜل ﻤﺸﺎﺭﻴﻊ ﻴﻤﻜﻨﻙ ﺍﻟﺒﺩﺀ ﻓﻴﻬﺎ.‬ ‫ﻴﻤﻜﻨﻙ ﺍﻀﺎﻓﺔ ﺍﻟﻤﺯﻴﺩ ﻤﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ ﺒﻤﺨﺘﻠﻑ ﺍﻨﻭﺍﻋﻬﺎ، ﻭﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﻅﺭﻴﻔﺔ ﺍﻟﺘﻲ ﺘﻤﻜﻨﻙ ﻤـﻥ ﺍﻟﺘﺤﻭﻴـل‬ ‫ﺒﻴﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ ﻫﻲ ﻨﺎﻓﺫﺓ ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤﺎل ‪) Solution Explorer‬ﺸﻜل 1 -6(.‬ ‫ﺒﺎﻟﻨﺴﺒﺔ ﻟﻤﻠﻔﺎﺕ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﻤﻨﺠﺯﺓ ﺒﻠﻐﺔ ‪ Visual Basic .NET‬ﻓﺠﻤﻴﻌﻬـﺎ ﺘﻨﺘﻬـﻲ ﺒﺎﻻﻤﺘـﺩﺍﺩ ‪.vb‬‬ ‫ﻤﻬﻤﺎ ﻜﺎﻥ ﻨﻭﻋﻬﺎ )ﺴﻭﺍﺀ ﻤﻠﻔﺎﺕ ﺍﺩﻭﺍﺕ ﺍﻟـﺘﺤﻜﻡ ‪ ،UserControls‬ﻨﻤـﺎﺫﺝ ‪ ،Windows Forms‬ﺍﻟﻔﺌـﺎﺕ‬ ‫‪... Classes‬ﺍﻟﺦ(، ﻭﻓﻲ ﺍﻟﺤﻘﻴﻘﺔ ﻴﻤﻜﻥ ﻟﻠﻤﻠﻑ ﺍﻟﻭﺍﺤﺩ ﺍﻥ ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﺠﻤﻴﻊ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺴﺎﺒﻘﺔ.‬
  • 49.
    ‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮفﻋﻠﻰ ‪V isual Basic .NET‬‬ ‫32‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫اﻧﻮاع اﻟﻤﺸﺎرﻳﻊ‬ ‫ﻴﻤﻜﻨﻙ ‪ Visual Basic .NET‬ﻤﻥ ﺩﻤﺞ ﻋﺩﺓ ﺍﻨﻭﺍﻉ ﻤﺨﺘﻠﻔـﺔ ﻤـﻥ ﺍﻟﻤﺸـﺎﺭﻴﻊ ﻜـﺎﺩﻭﺍﺕ ﺍﻟـﺘﺤﻜﻡ ‪User‬‬ ‫‪ ،Controls‬ﺘﻁﺒﻴﻘﺎﺕ ﻗﻴﺎﺴﻴﺔ ‪ ،Windows Application‬ﻤﻜﺘﺒﺎﺕ ﺍﻟﻔﺌـﺎﺕ ‪ Class Library‬ﻭﻏﻴﺭﻫـﺎ،‬ ‫ﺭﺒﻤﺎ ﺘﻜﻭﻥ ﻗﺩ ﻻﺤﻅﺘﻬﺎ ﻓﻲ ﺼﻨﺩﻭﻕ ﺍﻟﺤﻭﺍﺭ ﺍﻟﺴﺎﺒﻕ ‪ ،New Projects‬ﻭﺍﻟﻴﻙ ﻴﺎ ﻗـﺎﺭﺌﻲ ﺍﻟﻌﺯﻴـﺯ ﻤﻠﺨـﺹ‬ ‫ﻋﻨﻬﺎ:‬ ‫‪:Windows Application‬‬ ‫ﻭﻫﻲ ﻤﺸﺎﺭﻴﻊ ﺘﺸﺎﺒﻪ ﺘﻁﺒﻴﻘﺎﺕ ‪ Windows‬ﺍﻟﻘﻴﺎﺴـﻴﺔ ) ﺍﻱ ‪ .(Standard Application‬ﺍﻟﺠـﺯﺀ ﺍﻟﺜﺎﻟـﺙ‬ ‫ﺘﻁﻭﻴﺭ ﺘﻁﺒﻴﻘﺎﺕ ‪ Windows‬ﻤﺨﺼﺹ ﻟﻬﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ.‬ ‫‪:Class Library‬‬ ‫ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﻤﻜﺘﺒﺔ ﻓﺌﺎﺕ ﻴﻤﻜﻨﻙ ﺍﻻﺴﺘﻔﺎﺩﺓ ﻤﻨﻬﺎ ﻓﻲ ﺒـﺭﺍﻤﺞ ﺍﺨـﺭﻯ، ﻜﻤـﺎ ﻴﻤﻜﻨـﻙ‬ ‫ﺘﺭﺠﻤﺘﻬﺎ ﺍﻟﻰ ﻤﻠﻔﺎﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ DLL‬ﺍﻭ ﺤﺘﻰ ‪ EXE‬ﺍﻥ ﺍﺭﺩﺕ.‬ ‫‪:Windows Control Library‬‬ ‫ﻴﻤﻜﻨﻙ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ ﻤـﻥ ﺍﻨﺸـﺎﺀ ﺍﺩﻭﺍﺕ ﺘﺤﻜـﻡ ‪ User Controls‬ﺘﺴـﺘﺨﺩﻤﻬﺎ ﻓـﻲ ﺘﻁﺒﻴﻘـﺎﺕ‬ ‫‪ .Windows Application‬ﺴﻨﻁﺒﻕ ﺍﺩﻭﺍﺕ ﺍﻟﺘﺤﻜﻡ ﺒﻌﺩ ﻤﺌﺎﺕ ﺍﻟﺼﻔﺤﺎﺕ ﺍﻟﻰ ﺍﻥ ﻨﺼل ﻟﻠﻔﺼـل ﺍﻟﺴـﺎﺩﺱ‬ ‫ﻋﺸﺭ ﻤ ﻭﺍﻀﻴﻊ ﻤﺘﻘﺩﻤﺔ.‬ ‫‪:ASP .NET Web Application‬‬ ‫ﻴﻤﻜﻨﻙ ﻤﻥ ﺍﻨﺸﺎﺀ ﻤﺸﺎﺭﻴﻊ ‪ ASP .NET‬ﺒﺤﻴﺙ ﺘﻌﻤل ﻓﻲ ﺠﻬﺔ ﺍﻟﺨﺎﺩﻡ ‪ Server‬ﻭﻴﺘﻡ ﻋﺭﺽ ﺼﻔﺤﺎﺘﻬﺎ ﻋـﻥ‬ ‫ﻁﺭﻴﻕ ﻋﻤﻼﺀ ‪ Clients‬ﺒﺎﺤـﺩ ﺍﻟﻤﺘﺼـﻔﺤﺎﺕ ‪ .Browsers‬ﺍﻟﻔﺼـﻼﻥ ﺍﻟﻌﺸـﺭﻭﻥ ﻭﺍﻟﺤـﺎﺩﻱ ﻭﺍﻟﻌﺸـﺭﻭﻥ‬ ‫ﺘﻁﺒﻴﻘﺎﺕ ‪ ASP .NET‬ﻤﺨﺼﺹ ﻟﻬﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ.‬ ‫‪:ASP .NET Web Service‬‬ ‫ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ ﻴﺴﻬل ﻋﻠﻴـﻙ ﻋﻤﻠﻴـﺔ ﺘﺒـﺎﺩل ﺍﻟﺒﻴﺎﻨـﺎﺕ ﻋﺒـﺭ ﺍﻻﻨﺘﺭﻨـﺕ ﻋـﻥ ﻁﺭﻴـﻕ ﺍﺴـﺘﺨﺩﺍﻡ‬ ‫ﺒﺭﻭﺘﻭﻜﻭﻻﺕ ‪ TCP/IP‬ﻭ ‪ XML‬ﺍﻟﻘﻴﺎﺴﻴﺔ ﺩﻭﻥ ﺍﻟﺤﺎﺠﺔ ﺍﻟﻰ ﺘﻁﻭﻴﺭ ﺍﻟﻤﻜﻭﻨﺎﺕ ﺍﻟﻤﻭﺯﻋـﺔ ‪– DCOM‬ﻜﻤـﺎ‬ ‫ﺴﺘﺭﻯ ﻻﺤﻘﺎ ﻓﻲ ﺍﻟﻔﺼل ﺍﻟﺜﺎﻨﻲ ﻭﺍﻟﻌﺸﺭﻭﻥ ﺨﺩﻤﺎﺕ ﻭﻴﺏ ‪.Web Services‬‬ ‫‪:Web Control Library‬‬ ‫ﻴﻤﻜﻨﻙ ﺘﻁﻭﻴﺭ ﻤﺸﺎﺭﻴﻊ ﺸﺒﻴﻬﺔ ﺒﺎﺩﻭﺍﺕ ﺍﻟﺘﺤﻜﻡ ﻟﻜﻨﻬﺎ ﺨﺎﺼـﺔ ﻟﻠﻌـﺭﺽ ﻋﻠـﻰ ﺼـﻔﺤﺎﺕ ‪ ،HTML‬ﻭﻫـﻲ‬ ‫ﻤﺸﺎﺒﻬﺔ ﺍﻟﻰ ﺤﺩ ﻜﺒﻴﺭ ﺒﻤﺸـﺎﺭﻴﻊ ﺍﺩﻭﺍﺕ ﺍﻟـﺘﺤﻜﻡ ‪ ،User Controls‬ﻭﻟﻜﻨﻬـﺎ ﺘﻌـﺭﺽ ﻓـﻲ ﺍﻟﻤﺴـﺘﻌﺭﺽ‬ ‫‪.Browser‬‬
  • 50.
    ‫42‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫‪:Console Application‬‬ ‫ﺍﺫﺍ ﻜﻨﺕ ﺘﺸﻌﺭ ﺒﺎﻟﺤﻨﻴﻥ ﺍﻟﻰ ﺘﻁﻭﻴﺭ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﺘﺤﺕ ﺒﻴﺌﺔ ‪ DOS‬ﻓﻬﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻤﻨﺎﺴـﺏ ﻟـﻙ ﺘﻤﺎﻤـﺎ. ﺒﺎﻟﻨﺴـﺒﺔ‬ ‫ﹰ‬ ‫ﻟﻨﺎ، ﺴﻨﺴﺘﻤﺭ ﻓﻲ ﺘﻁﻭﻴﺭ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ ﺤﺘﻰ ﻨﻬﺎﻴﺔ ﺍﻟﺠﺯﺀ ﺍﻟﺜﺎﻨﻲ ﻤﻥ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ.‬ ‫‪:Windows Services‬‬ ‫ﻨﻭﻉ ﺨﺎﺹ ﻤﻥ ﺘﻁﺒﻴﻘﺎﺕ ‪ Windows‬ﺍﻟﻘﻴﺎﺴﻴﺔ ﺒﺤﻴﺙ ﻴﻌﻤل ﻓﻲ ﺍﻟﺨﻠﻔﻴﺔ ‪ Background‬ﺩﺍﺌﻤـﺎ ﻤﻨـﺫ ﺒﺩﺍﻴـﺔ‬ ‫ﺘﺤﻤﻴل ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ﺤﺘﻰ ﺍﻏﻼﻕ ﺠﻬﺎﺯ ﺍﻟﻜﻤﺒﻴﻭﺘﺭ. ﻟﻲ ﻋﻭﺩﺓ ﺍﻟﻰ ﻫـﺫﺍ ﺍﻟﻤﻭﻀـﻭﻉ ﻓـﻲ ﺍﻟﻔﺼـل ﺍﻟﺴـﺎﺩﺱ‬ ‫ﻋﺸﺭ ﻤﻭﺍﻀﻴﻊ ﻤﺘﻘﺩﻤﺔ.‬ ‫‪:Empty Project‬‬ ‫ﺴﻬﻠﺔ ﺠﺩﺍ ﻭﻻ ﺘﺤﺘﺎﺝ ﺍﻟﻰ ﺘﻔﺎﺼﻴل.‬ ‫‪:Empty Web Project‬‬ ‫ﺍﺴﻬل ﻤﻥ ﺴﺎﺒﻘﺘﻬﺎ.‬ ‫ﺒﻌﺩ ﻫﺫﻩ ﺍﻟﺠﻭﻟﺔ ﺍﻟﺴﺭﻴﻌﺔ ﺤﻭل ﺍﻨﻭﺍﻉ ﺍﻟﻤﺸﺎﺭﻴﻊ، ﻴﺅﺴﻔﻨﻲ ﺍﺨﺒﺎﺭﻙ ﺒﺎﻥ ﻤﺎ ﺫﻜﺭﻨﺎﻩ ﻫـﻭ ﻤﺠـﺭﺩ ﻗﻭﺍﻟـﺏ‬ ‫‪ Templates‬ﺘﻘﻭﻡ ﺒﺘﻭﻟﻴﺩ ﺍﻟﺸﻴﻔﺭﺍﺕ ﺍﻟﻀﺭﻭﺭﻴﺔ ﻟﻌﻤل ﻤﺎ ﺘﺭﻴﺩ، ﺒل ﺤﺘﻰ ﻴﻤﻜﻨﻙ ﺍﻨﺸـﺎﺀ ﺍﻟﻤﺯﻴـﺩ ﻤـﻥ ﻫـﺫﻩ‬ ‫ﺍﻟﻘﻭﺍﻟﺏ ﺍﻭ ﺤﺫﻑ ﺍﻟﺤﺎﻟﻴﺔ، ﻓﺎﻟﺤل ﺍﻟﻭﺍﺤـﺩ ﻗـﺩ ﻴﺸـﻤل ﺨﺩﻤـﺔ ‪ Windows Service‬ﻭ ﺒﺭﻨـﺎﻤﺞ ﻗﻴﺎﺴـﻲ‬ ‫‪ Windows Application‬ﻭ ﺍﺩﺍﺓ ﺘﺤﻜﻡ ‪ ،User Control‬ﺍﻟﺴﺭ ﻜﻠـﻪ ﻴﻜﻤـﻥ ﻓـﻲ ﺸـﻴﻔﺭﺍﺕ ﻤﻠﻔـﺎﺕ‬ ‫ﺍﻟﻤﺸﺭﻭﻉ.‬ ‫ﺑﻨﺎء ﺑﺮﻧﺎﻣﺠﻚ اﻻول‬ ‫ﻜل ﺍﻟﻁﺭﻕ ﺘﺅﺩﻱ ﺍﻟﻰ ﺭﻭﻤﺎ ﻫﻲ ﻤﻘﻭﻟﺔ ﻗﺩﻴﻤﺔ، ﻟﺩﻴﻙ ﻋﺸﺭﺍﺕ ﺍﻟﻁﺭﻕ ﻭﺍﻟﻭﺴﺎﺌل ﺍﻟﺘـﻲ ﺘﻤﻜﻨـﻙ ﻤـﻥ ﻜﺘﺎﺒـﺔ‬ ‫ﺒﺭﻨﺎﻤﺠﻙ ﺍﻻﻭل ﺒـ ‪ Visual Basic .NET‬ﺍﺒﺘﺩﺍﺀ ﻤﻥ ﻤﻠﻔﺎﺕ ﻨﺼـﻴﺔ ﺒﺎﺴـﺘﺨﺩﺍﻡ ﺍﻟﻤﻔﻜـﺭﺓ ‪ Notepad‬ﺍﻭ‬ ‫ﺤﺘﻰ ﺍﺴﺘﺨﺩﺍﻡ ﺍﺤﺩ ﺍﻟﻘﻭﺍﻟﺏ ﺍﻟﺠﺎﻫﺯﺓ -ﻜﻘﺎﻟﺏ ‪.Console Application‬‬ ‫ﻤﺎ ﻴﻬﻤﻨﻲ ﻓﻲ ﻫﺫﺍ ﺍﻟﻔﺼل ﺍﻋﻁﺎﺌﻙ ﺍﻟﺨﻁﻭﺍﺕ ﺍﻻﺴﺎﺴﻴﺔ ﻟﺒﻨـﺎﺀ ﺒﺭﺍﻤﺠـﻙ ﺍﻷﻭل ﺒــﺎﺴﺘﺨﺩﺍﻡ ‪Visual‬‬ ‫‪ Basic .NET‬ﻭﻟﻴﺱ ﺍﻟﺒﺩﺀ ﺍﻟﻔﻌﻠﻲ ﺒﺸﺭﺡ ﻗﻭﺍﻋﺩ ﻭﻤﻔﺭﺩﺍﺕ ﺍﻟﻠﻐﺔ، ﻓﻠﻥ ﺍﻗﺩﻡ ﻟﻙ ﺍﻟﻜﺜﻴﺭ ﻤـﻥ ﺍﻟﺘﻔﺎﺼـﻴل، ﻤـﺎ‬ ‫ﺍﻨﺸﺩﻩ ﻫﻨﺎ ﻫﻭ ﺘﻭﻀﻴﺢ ﻋﻤﻠﻴﺔ ﺒﻨﺎﺀ ﺍﻟﻤﺸﺎﺭﻴﻊ ﻭﺘﻨﻔﻴﺫﻫﺎ ﻓﻘﻁ.‬ ‫ﺍﻨﺸﺊ ﺍﻱ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ﻭﻟﻨﻘل ‪ Console Application‬ﻋﻠﻰ ﺴﺒﻴل ﺍﻟﻤﺜـﺎل ﻓﻘـﻁ، ﺴـﺘﻼﺤﻅﺔ ﺍﻥ‬ ‫ﻨﺎﻓﺫﺓ ﻤﺤﺭﺭ ﺍﻟﺸﻴﻔﺭﺓ ﻗﺩ ﻓﺘﺤﺕ ﻭﻜﺘﺏ ﺒﻬﺎ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ:‬ ‫1‪Module Module‬‬ ‫)(‪Sub Main‬‬ ‫‪End Sub‬‬ ‫‪End Module‬‬
  • 51.
    ‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮفﻋﻠﻰ ‪V isual Basic .NET‬‬ ‫52‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻏﻴﺭ ﺍﺴﻡ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ 1‪ Module‬ﺇﻟﻰ ‪ ،FirstProg‬ﺍﺴﺘﺨﺩﻡ ﺍﻟﻜﺎﺌﻥ ‪ Console‬ﻟﻌـﺭﺽ ﺍﻟﻤﺨﺭﺠـﺎﺕ‬ ‫ﻋﻠﻰ ﺍﻟﺸﺎﺸﺔ. ﻫﺫﺍ ﺒﺭﻨﺎﻤﺠﻙ ﺍﻻﻭل ﻭﻫﻭ ﻴﻘﻭﻡ ﺒﻌﺭﺽ ﺍﻟﺒﺴﻤﻠﺔ ﻟﺘﻜﻭﻥ ﻓﺎﺘﺤﺔ ﺨﻴﺭ ﻋﻠﻴﻨﺎ ﺒﻤﺸﻴﺌﺔ ﺍﷲ:‬ ‫‪Module FirstProg‬‬ ‫)(‪Sub Main‬‬ ‫)" ‪Cons ole.W riteL ine(" In th e nam e of Allah the most graci ous a nd th e mos t mer ciful‬‬ ‫‪End Sub‬‬ ‫‪End Module‬‬ ‫ﺍﻀﻐﻁ ﻋﻠﻰ ﺍﻟﻤﻔﺘﺎﺡ ]5‪ [ F‬ﺍﻭ ﺍﺨﺘﺭ ﺍﻻﻤﺭ ‪ Start‬ﻤﻥ ﻗﺎﺌﻤﺔ ‪ Debug‬ﻟﺘﻨﻔﻴﺫ ﺍﻟﻤﺸﺭﻭﻉ، )ﻤﻊ ﺍﻟﻌﻠﻡ ﺍﻥ ﻋﻤﻠﻴـﺔ‬ ‫ﺍﻟﺘﻨﻔﻴﺫ ﺘﺅﺩﻱ ﺍﻟﻰ ﻋﻤﻠﻴﺔ ﺍﻟﺘﺭﺠﻤﺔ ‪ Compiling‬ﺒﺸﻜل ﺘﻠﻘﺎﺌﻲ( ﺴﺘﻼﺤﻅ ﺍﻥ ﻨﺎﻓﺫﺓ ﺴـﻭﺩﺍﺀ ﻅﻬـﺭﺕ ﻭﺍﺨﺘﻔـﺕ‬ ‫ﺒﺴﺭﻋﺔ، ﻭﻟﻜﻲ ﺘﺘﻤﻜﻥ ﻤﻥ ﺍﻴﻘﺎﻓﻬﺎ ﺍﻀﻑ ﺍﻻﻤﺭ ﺍﻟﺘﺎﻟﻲ ﻓـﻲ ﺍﻟﺒﺭﻨـﺎﻤﺞ ﺍﻟﺴـﺎﺒﻕ، ﺒﺤﻴـﺙ ﻴﺴـﻤﺢ ﻟﻠﻤﺴـﺘﺨﺩﻡ‬ ‫ﺒﺎﻟﻀﻐﻁ ﻋﻠﻰ ﻤﻔﺘﺎﺡ ] ‪ [ ENTER‬ﻗﺒل ﺍﺨﻔﺎﺀ ﺍﻟﻨﺎﻓﺫﺓ:‬ ‫‪Module FirstProg‬‬ ‫)(‪Sub Main‬‬ ‫…‬ ‫)(‪Console.Read‬‬ ‫‪End Sub‬‬ ‫‪End Module‬‬ ‫ﺍﻋﺩ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻟﺘﺭﻯ ﻤﺨﺭﺠﺎﺘﻪ )ﺸﻜل 1 -21(.‬ ‫ﺸﻜل 1 -21: ﻤﺨﺭﺠﺎﺕ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻻﻭل.‬ ‫اﺳﺘﺨﺪام ‪ArabicConsole‬‬ ‫ﺍﻀﻁﺭﺭﺕ ﻓﻲ ﺍﻟﻔﻘﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ ﻻﺴﺘﺨﺩﺍﻡ ﺍﻟﻠﻐﺔ ﺍﻻﻨﺠﻠﻴﺯﻴﺔ ﻟﻌـﺭﺽ ﻤﺨﺭﺠـﺎﺕ ﺍﻟﺒﺭﻨـﺎﻤﺞ ﺍﻻﻭل ﻭﺫﻟـﻙ ﻻﻥ‬ ‫ﺍﻟﻜﺎﺌﻥ ‪ Console‬ﻻ ﻴﺩﻋﻡ ﺍﻟﺤﺭﻭﻑ ﺍﻟﻌﺭﺒﻴﺔ، ﻭﺒﻤﺎ ﺍﻨﻲ ﺴﺎﻋﺘﻤﺩ ﻋﻠﻰ ﻫـﺫﺍ ﺍﻟﻜـﺎﺌﻥ ﻓـﻲ ﺸـﺭﺡ ﺍﻟﺸـﻴﻔﺭﺍﺕ‬ ‫ﺍﻟﻤﺼﺩﺭﻴﺔ ﻓﻼﺒﺩ ﻤﻥ ﺍﺴﺘﺨﺩﺍﻤﻪ، ﻭﺒﺩﻻ ﻤﻥ ﺠﻌل ﺍﻤﺜﻠﺔ ﺍﻟﻜﺘﺎﺏ ﺘﻌﺘﻤـﺩ ﻋﻠـﻰ ﺍﻟﻜﻠﻤـﺎﺕ ﺍﻻﻨﺠﻠﻴﺯﻴـﺔ، ﻓﻜـﺭﺕ‬ ‫ﺒﺘﻁﻭﻴﺭ ﻜﺎﺌﻥ ﻴﺤﻤل ﺍﻻﺴﻡ ‪ ArabicConsole‬ﻴﺤﺎﻜﻲ ﺍﻟﻜﺎﺌﻥ ‪ Console‬ﻴﻤﻜﻨـﻙ ﻤـﻥ ﺍﺴـﺘﺨﺩﺍﻡ ﺍﻟﺤـﺭﻭﻑ‬ ‫ﺍﻟﻌﺭﺒﻴﺔ. ﻀﻊ ﻓﻲ ﺍﻻﻋﺘﺒﺎﺭ، ﺍﻥ ﺍﻟﻜـﺎﺌﻥ ‪ ArabicConsole‬ﻻ ﻴﺤﺘـﻭﻱ ﺍﻻ ﻋﻠـﻰ ﻁﺭﻴﻘـﺔ ﻭﺍﺤـﺩﺓ ﻫـﻲ‬
  • 52.
    ‫62‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫)(‪ WriteLine‬ﻓﻘﻁ، ﻭﻫﻲ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﻭﺤﻴﺩﺓ ﺍﻟﺘﻲ ﻨﺤﺘﺎﺠﻬﺎ ﻟﻌﺭﺽ ﺍﻟﻤﺨﺭﺠﺎﺕ. ﺍﻥ ﻜﻨﺕ ﺘﻭﺩ ﺍﺴـﺘﺨﺩﺍﻡ ﻫـﺫﺍ‬ ‫ﺍﻟﻜﺎﺌﻥ ﻓﻲ ﻤﺸﺎﺭﻴﻌﻙ، ﻓﻴﻤﻜﻥ ﺍﻀﺎﻓﺘﻪ ﻋﻥ ﻁﺭﻴﻕ ﻨﺎﻓﺫﺓ ﺍﻟﻤﺭﺍﺠـﻊ )ﺸـﻜل 1 -7( ﻭﺍﻟﻀـﻐﻁ ﻋﻠـﻰ ﺍﻟـﺯﺭ‬ ‫‪ Brows‬ﻭﻤﻥ ﺜﻡ ﺍﻟﺒﺤﺙ ﻋﻥ ﺍﻟﻤﻠﻑ ‪ ArabicConsole.DLL‬ﻓﻲ ﺍﻟﺩﻟﻴل ﺍﻟﺠﺫﺭﻱ ﻟﻠﻘﺭﺹ ﺍﻟﻤﺩﻤﺞ.‬ ‫ﺒﻌﺩ ﺍﻀﺎﻓﺘﻙ ﻟﻤﺭﺠﻊ ﺍﻟﻜﺎﺌﻥ ‪ ArabicConsole‬ﻓﻲ ﻤﺸﺭﻭﻋﻙ، ﺘﺴﺘﻁﻴﻊ ﺍﺴﺘﺨﺩﺍﻤﺔ ﻤﺒﺎﺸـﺭﺓ ﻭﺘﻜﺘـﺏ‬ ‫ﺸﻴﺌﺎ ﻤﺜل:‬ ‫اﺿﻒ هﺬا اﻟﺴﻄﺮ ﻗﺒﻞ اﺳﺘﺨﺪ ام اﻟ ﻜﺎﺋ ﻦ '‬ ‫‪' ArabicConsole‬‬ ‫‪Imports ArabicConsoleProject‬‬ ‫)"ﺑﺴﻢ اﷲ اﻟ ﺮﲪﻦ ا ﻟﺮﺣﻴ ﻢ"(‬ ‫‪Module FirstProg‬‬ ‫)(‪Sub Main‬‬ ‫‪ArabicConsole.WriteLine‬‬ ‫‪End Sub‬‬ ‫‪End Module‬‬ ‫اﻧﻈﺮ اﻳﻀﺎ‬ ‫ﺳﺘﻔﻬﻢ اﻟﻐﺮض ﻣﻦ اﺳـﺘﺨﺪام اﻟﻌﺒـﺎرة ‪Imports A rabicConsoleProject‬‬ ‫ﻓﻲ اﻟﻔ ﺼﻞ اﻟﺘﺎﻟﻲ ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ ﺑﻤﺸﻴﺌﺔ اﷲ.‬ ‫ﻟﺴﺕ ﺒﺤﺎﺠﺔ ﻻﺴﺘﺨﺩﺍﻡ ﺍﻟﻁﺭﻴﻘﺔ )(‪ Read‬ﺤﺘﻰ ﺘﻤﻨﻊ ﺍﻟﻨﺎﻓﺫﺓ ﻤﻥ ﺍﻻﻏﻼﻕ ﺍﻟﺘﻠﻘـﺎﺌﻲ، ﺤﻴـﺙ ﺍﻥ ﺍﻟﻜـﺎﺌﻥ‬ ‫‪ ArabicConsole‬ﻴﻌﻁﻴﻙ ﻓﺭﺼﺔ ﺍﻏﻼﻗﻬﺎ ﺒﻨﻔﺴﻙ.‬ ‫اﻟﺘﺮﺟﻤﺔ واﻟﺘﻮزﻳﻊ‬ ‫ﺍﻟﻨﻘﻁﺔ ﺍﻻﺨﻴﺭﺓ ﺍﻟﺘﻲ ﺍﺭﻴﺩ ﺍﻟﺘﻁﺭﻕ ﻟﻬﺎ ﻫﻲ ﻋﻤﻠﻴـﺔ ﺘﺭﺠﻤـﺔ ﺍﻟﺒﺭﻨـﺎﻤﺞ ‪ Compiling‬ﻭﺘﻭﺯﻴﻌـﻪ، ﺒﺎﻟﻨﺴـﺒﺔ‬ ‫ﻟﻠﺘﺭﺠﻤﺔ ﻓﺘﻭﺠﺩ ﻋﺸﺭﺍﺕ ﺍﻟﺨﻴﺎﺭﺍﺕ ﺍﻟﻤﻌﻘﺩﺓ -ﺒﺎﻟﻨﺴﺒﺔ ﻟﻲ - ﺘﺤﺩﺩ ﺒﻬـﺎ ﺴـﻠﻭﻙ ﺍﻟﻤﺘـﺭﺠﻡ ‪ ،Compiler‬ﺍﻻ ﺍﻥ‬ ‫ﻓﺭﻴﻕ ﺍﻟﺘﻁﻭﻴﺭ ﻟـ ‪ Visual Studio .NET‬ﻗﺩ ﺴﻬﻠﻭﺍ ﻋﻠﻴﻨﺎ ﻋﻤل ﺫﻟﻙ ﺒﺘﺠﻬﻴـﺯ ﻫـﺫﻩ ﺍﻟﺨﻴـﺎﺭﺍﺕ ﺒﺸـﻜل‬ ‫ﻤﺒﺩﺌﻲ ﺒﺤﻴﺙ ﻴﻨﺎﺴﺏ ﺍﻏﻠﺏ ﺍﻟﺤﺎﻻﺕ، ﺘﻌﺭﻑ ﻫﺫﻩ ﺍﻻﻋﺩﺍﺩﺍﺕ ﺒـ ‪ .Configurations‬ﺒﺸﻜل ﻤﺒـﺩﺌﻲ ﻴﻤﻜﻨـﻙ‬ ‫ﺭﺅﻴﺔ ﺍﺤﺩ ﻫﺫﻩ ﺍﻻﻋﺩﺍﺩﺍﺕ ﻭﻫﻭ ﺍﻟﻨﺹ ﺍﻟﻤﻌﻨـﻭﻥ ‪ Debug‬ﻓـﻲ ﺸـﺭﻴﻁ ﺍﻻﺩﻭﺍﺕ ﺍﻟﻌﻠـﻭﻱ ﻟﺒﻴﺌـﺔ ﺍﻟﺘﻁـﻭﻴﺭ‬ ‫‪) Visual Studio .NET‬ﺸﻜل 1 -31(:‬ ‫ﺸﻜل 1 -31: ﺍﻋﺩﺍﺩﺍﺕ ﺍﻟﺘﺭﺠﻤﺔ‬
  • 53.
    ‫اﻟﻔﺼﻞ اﻻول: ﺗﻌﺮفﻋﻠﻰ ‪V isual Basic .NET‬‬ ‫72‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺒﺎﻟﻨﺴﺒﺔ ﻟﻼﻋﺩﺍﺩﺍﺕ ‪ Release‬ﻓﺤﺩﺩﻫﺎ ﺍﺫﺍ ﻜﺎﻨﺕ ﻫﺫﻩ ﺍﺨﺭ ﻤﺭﺓ ﺘﻘﻭﻡ ﻓﻴﻬﺎ ﺒﻌﻤﻠﻴـﺔ ﺘﺭﺠﻤـﺔ ﺍﻟﺒﺭﻨـﺎﻤﺞ‬ ‫ﻭﻋﻨﺩﻤﺎ ﺘﻜﻭﻥ ﺠﺎﻫﺯ ﻟﺘﻭﺯﻴﻊ ﺍﻟﺒﺭﻨﺎﻤﺞ. ﻴﻤﻜﻨﻙ ﺍﻀﺎﻓﺔ ﺍﻋﺩﺍﺩﺍﺕ ﺠﺩﻴـﺩﺓ ﺍﻭ ﺘﺤﺭﻴـﺭ ﻫـﺫﻩ ﺍﻻﻋـﺩﺍﺩﺍﺕ ﻭﺍﻟﺘـﻲ‬ ‫ﺘﺠﺩﻫﺎ ﻓﻲ ﻗﺎﺌﻤﺔ ‪ Configuration Properties‬ﻤﻥ ﺍﺩﺍﺓ ﺍﻟﺸﺠﺭﺓ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺼﻨﺩﻭﻕ ﺤﻭﺍﺭ ﺨﺼـﺎﺌﺹ‬ ‫ﺍﻟﻤﺸﺭﻭﻉ ‪.Project Properties‬‬ ‫ﺍﺨﻴﺭﺍ، ﺍﺫﺍ ﺍﺭﺩﺕ ﺘﻭﺯﻴﻊ ﺒﺭﻨﺎﻤﺠﻙ ﺍﻟﻰ ﺍﺠﻬﺯﺓ ﺍﺨﺭﻯ ﻋﻠﻴﻙ ﺍﺭﻓـﺎﻕ ﻤﻜﺘﺒـﺎﺕ ‪.NET Framework‬‬ ‫ﻤﻊ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺤﺘﻰ ﺘﻌﻤل، ﻴﻤﻜﻨﻙ ﺍﻨﺯﺍل ﻫﺫﻩ ﺍﻟﻤﻜﺘﺒﺎﺕ ﻤﻥ ﻤﻭﻗﻊ ‪ microsoft.com‬ﺍﻭ ﻴﻔﻀل ﺍﺭﻓﺎﻗﻬـﺎ ﻓـﻲ‬ ‫ﺍﺴﻁﻭﺍﻨﺔ ﻤﺴﺘﻘﻠﺔ ﻻﻥ ﺤﺠﻤﻬﺎ ﻴﺯﻴﺩ ﻋﻥ 001 ﻤﻴﺠﺎ ﺒﺎﻴﺕ.‬ ‫ﻗﺩ ﺘﻜﻭﻥ ﺍﺼﺒﺕ ﺒﺎﻻﺤﺒﺎﻁ ﺍﻟﻤﺒﺩﺌﻲ ﻤﻥ ﻫﺫﺍ ﺍﻟﻔﺼل ﻭﻟﻡ ﺘﺴﺘﻔﺩ ﻤﻨﻪ ﺍﻟﺸـﺊ ﺍﻟﻜﺜﻴـﺭ، ﻭﻟﻜـﻥ ﺼـﺩﻗﻨﻲ ﺍﻟﺒﺩﺍﻴـﺔ‬ ‫ﺍﻟﺤﻘﻴﻘﻴﺔ ﺴﺘﻠﻤﺴﻬﺎ ﺍﻋﺘﺒﺎﺭﺍ ﻤﻥ ﺍﻟﻔﺼل ﺍﻟﺘﺎﻟﻲ ﻭﺤﺘﻰ ﻨﻬﺎﻴﺔ ﺍﻟﻜﺘﺎﺏ، ﻭﺴﺘﺭﻯ ﻤﺌـﺎﺕ ﺍﻻﺴـﻁﺭ ﻤـﻥ ﺍﻟﺸـﻴ ﻔﺭﺍﺕ‬ ‫ﹰ‬ ‫ﺍﻟﻤﺼﺩﺭﻴﺔ ﻤﻊ ﺸﺭﺡ ﻭﺍﻓﻲ ﻟﻜل ﺸﺊ ﻤﺒﻬﻡ ﻟﻡ ﺘﻔﻬﻤﻪ ﻓﻲ ﻫﺫﺍ ﺍﻟﻔﺼل، ﻓﻬـﺩﻓﻲ ﻫﻨـﺎ ﺘﻘـﺩﻴﻡ ﺠﻭﻟـﺔ ﺴـﺭﻴﻌﺔ‬ ‫ﻭﻤﺒﺴﻁﺔ ﺠﺩﺍ ﺤﻭل ﺘﻘﻨﻴﺔ ‪ ،.NET‬ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ ‪ ،Visual Studio .NET‬ﻭﻁﺭﻴﻘﺔ ﻜﺘﺎﺒﺔ ﺍﻭل ﺒﺭﻨﺎﻤﺞ ﻟـﻙ‬ ‫ﺒـ ‪ .Visual Basic .NET‬ﺇﻗﻠﺏ ﺍﻟﺼﻔﺤﺔ ﻟﺘﺒﺩﺃ ﺘﻌﻠﻡ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ‪ Visual Basic .NET‬ﻤﻥ ﺍﻟﺼـ ﻔﺭ‬ ‫ﻓﻲ ﺍﻟﻔﺼل ﺍﻟﺘﺎﻟﻲ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ.‬
  • 55.
    ‫2‬ ‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ‬ ‫ﺇﻥﻜﻨﺕ ﺘﻌﺘﻘﺩ ﺒﺄﻨﻨﻲ ﺴﺄﺒﺩﺃ ﻤﻌﻙ ﻓﻲ ﺘﺼﻤﻴﻡ ﺍﻟﻨﻭﺍﻓﺫ ﻭﻭﻀﻊ ﺍﻷﺩﻭﺍﺕ ﻋﻠﻴﻬﺎ، ﻓﻴﺅﺴﻔﻨﻲ ﺍﺨﺒﺎﺭﻙ ﺃﻥ ﺍﻟﻭﻗـﺕ ﻤـﺎ‬ ‫ﺯﺍل ﻤﺒﻜﺭﺍ ﺠﺩﺍ ﻟﻠﺤﺩﻴﺙ ﻋﻨﻬﺎ، ﺤﻴﺙ ﺍﻨﻲ ﻟﻥ ﺍﺘﻁﺭﻕ ﺍﻟﻰ ﻫﺫﻩ ﺍﻟﻤﻭﺍﻀﻴﻊ ﺇﻻ ﻤﻊ ﺒﺩﺍﻴـﺔ ﺍﻟﺠـﺯﺀ ﺍﻟﺜﺎﻟـﺙ ﻤـﻥ‬ ‫ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ ﺘﻁﻭﻴﺭ ﺘﻁﺒﻴﻘﺎﺕ ‪ .Windows‬ﻭﻟﻭ ﻜﺎﻥ ﺍﻻﻤﺭ ﺒﻴـﺩﻱ، ﻟﻨﺼـﺤﺕ ﺠﻤﻴـﻊ ﻤﺒﺭﻤﺠـﻲ ‪Visual‬‬ ‫‪ Basic .NET‬ﺍﻟﻌﺭﺏ ﺒﺄﻥ ﻻ ﻴﻘﻔﺯﻭﺍ ﺍﻟﻰ ﺒﺭﻤﺠﺔ ﻨﻤـﺎﺫﺝ ‪ Windows Forms‬ﺤﺘـﻰ ﻴﺘﻘﻨـﻭﺍ ﺃﺴﺎﺴـﻴﺎﺕ‬ ‫ﺍﻟﻠﻐﺔ، ﻓﻤﺴﺄﻟﺔ ﺍﺘﻘﺎﻥ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ‪ Visual Basic .NET‬ﺃﻤﺭ ﻓﻲ ﻏﺎﻴﺔ ﺍﻷﻫﻤﻴﺔ ﻗﺒل ﺍﻻﻨﺘﻘﺎل ﺇﻟﻰ ﺘﻁـﻭﻴﺭ‬ ‫ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﺍﻟﻤﺨﺘﻠﻔـﺔ ﻜــ ‪ ،Windows Applications‬ﺍﻭ ‪ ،Web Applications‬ﺍﻭ ‪Windows‬‬ ‫‪... Services‬ﺍﻟﺦ، ﺨﺎﺼـﺔ ﺇﻥ ﻋﻠﻤـﺕ ﺃﻥ ‪ Visual Basic .NET‬ﻟـﻴﺱ ﻤﻭﺠﻬـﺎ ﻟﺘﻁـﻭﻴﺭ ﺘﻁﺒﻴﻘـﺎﺕ‬ ‫ﹰ‬ ‫‪ Windows‬ﻭﺤﺴﺏ، ﺒل ﻴﻤﻜﻨﻙ ﻤﻥ ﺇﻨﺠﺎﺯ ﺍﻷﻨﻭﺍﻉ ﺍﻟﻤﺨﺘﻠﻔﺔ ﻤﻥ ﺍﻟﻤﺸﺎﺭﻴﻊ ﺍﻟﺘﻲ ﺘﻁﺭﻗﺕ ﺇﻟﻴﻬﺎ ﻓـﻲ ﺍﻟﻔﺼـل‬ ‫ﺍﻟﺴﺎﺒﻕ.‬ ‫ﺍﻋﺘﺒﺎﺭﺍ ﻤﻥ ﻫﺫﺍ ﺍﻟﻔﺼل ﻭﺤﺘﻰ ﺍﻟﻔﺼل ﺍﻟﺜﺎﻨﻲ ﻋﺸﺭ ﺴﻨﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻜﺎﺌﻥ ‪ ArabicConsole‬ﻟﻌـﺭﺽ‬ ‫ﹰ‬ ‫ﺍﻟﻤﺨﺭﺠﺎﺕ ﻋﻠﻰ ﺍﻟﺸﺎﺸﺔ، ﻭﺘﻭﻀﻴﺢ ﻨﺘﺎﺌﺞ ﺍﻟﺸﻴﻔﺭﺓ ﻟﺘـﺘﻌﻠﻡ ﻟﻐـﺔ ﺍﻟﺒﺭﻤﺠـﺔ ‪ Visual Basic .NET‬ﺒﺸـﻜل‬ ‫ﺴﻠﻴﻡ. ﻭﺴﺎﻓﺘﺭﺽ ﺍﻥ ﻟﺩﻴﻙ ﺨﻠﻔﻴﺔ –ﻭﻟﻭ ﺒﺴﻴﻁﺔ - ﻓﻲ ﺍﻟﺒﺭﻤﺠﺔ ﺒﻐﺽ ﺍﻟﻨﻅﺭ ﻋـﻥ ﺍﻟﻠﻐـﺔ ﺍﻟﺘـﻲ ﺍﺴـﺘﺨﺩﻤﺘﻬﺎ،‬ ‫ﺤﻴﺙ ﺃﻨﻰ ﻟﻥ ﺍﻀﻴﻊ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﻭﻗﺘﻲ ﻭﻭﻗﺘﻙ ﻓﻲ ﺸﺭﺡ ﺍﻟﻤﺴﺎﺌل ﺍﻟﻨﻅﺭﻴﺔ ) ﻜﺎﻟﺘﻜﺭﺍﺭ، ﺍﻟﺘﻔـﺭﻉ، ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ،‬ ‫ﺍﻹﺠﺭﺍﺀﺍﺕ ...ﺍﻟﺦ( ﻓﻠﺩﻱ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﻤﺴﺎﺌل ﺍﻟﺘﻁﺒﻴﻘﻴﺔ ﻭﺍﻟﺘﻲ ﺴﺘﻭﻀﺢ ﻟﻙ ﻗﻀـﺎﻴﺎ ﺃﻫـﻡ ﺒﻜﺜﻴـﺭ ﻓـﻲ ﻟﻐـﺔ‬ ‫ﺒﺭﻤﺠﺘﻙ ﺍﻟﺠﺩﻴﺩﺓ ‪.Visual Basic .NET‬‬ ‫اﻟﻮﺣﺪات اﻟﺒﺮﻣﺠﻴﺔ ‪Modules‬‬ ‫ﺍﻭل ﻤﺼﻁﻠﺢ ﺴﻨﺘﻌﺭﻑ ﻋﻠﻴﻪ ﻫﻭ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ ‪ ،Module‬ﻭﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﺤﺎﻭﻴﺔ ﺘﻤﻜﻨـﻙ ﻤـﻥ ﻜﺘﺎﺒـﺔ‬ ‫ﺠﻤﻴﻊ ﺸﻴﻔﺭﺍﺘﻙ ﺍﻟﻤﺼﺩﺭﻴﺔ ﺒﺩﺍﺨﻠﻬﺎ، ﻓﻠﻭ ﻋﺩﺕ ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻷﻭل ﻓﻲ ﺍﻟﻔﺼل ﺍﻟﺴﺎﺒﻕ، ﺴﺘﻼﺤﻅ ﺃﻨﻨـﺎ ﻋﺭﻓﻨـﺎ‬ ‫ﻭﺤﺩﺓ ﺒﺭﻤﺠﻴﺔ ﺒﺎﺴﻡ ‪ FirstProg‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪:Module‬‬ ‫‪Module FirstProg‬‬ ‫) (‪Sub Main‬‬ ‫)"ﺑﺴ ﻢ اﷲ اﻟﺮﲪﻦ اﻟﺮﺣ ﻴﻢ" (‪ArabicConsole.WriteLine‬‬ ‫‪End Sub‬‬ ‫‪End Module‬‬
  • 56.
    ‫03‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻻ ﻴﻤﻜﻨﻙ ﻜﺘﺎﺒﺔ ﺃﻱ ﺸﻴﻔﺭﺓ ﺨﺎﺭﺝ ﻨﻁﺎﻕ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ )ﺃﻱ ﻓـﻭﻕ ﺍﻟﺴـﻁﺭ ‪ Module X‬ﻭﺘﺤـﺕ‬ ‫ﺍﻟﺴﻁﺭ ‪ .(End Module‬ﻭﻟﻭ ﺘﺠﺭﺃﺕ ﻭﺼﺭﺤﺕ ﻋﻥ ﻤﺘﻐﻴﺭ ﺃﻭ ﺃﻋﻠﻨﺕ ﻋﻥ ﺇﺠﺭﺍﺀ ﺨـﺎﺭﺝ ﻨﻁـﺎﻕ ﺍﻟﻭﺤـﺩﺓ‬ ‫ﺍﻟﺒﺭﻤﺠﻴﺔ، ﻓﺄﻨﺕ ﻋﻤﻠﻴﺎ ﺘﻜﺘﺏ ﺨﺎﺭﺝ ﻨﻁﺎﻕ ﺍﻟﺤﺎﻭﻴﺔ، ﻭﺴﻴﻅﻬﺭ ﻟﻙ ﺍﻟﻤﺘـﺭﺠﻡ ﺭﺴـﺎﻟﺔ ﺨﻁـﺄ ‪Statement is‬‬ ‫ﹰ‬ ‫‪:not valid in a namespace‬‬ ‫ﻟﻦ ﻳﺘﻢ ﺗ ﻨﻔﻴﺬ اﻟﺸﻴﻔ ﺮة اﻟ ﺘﺎﻟﻴﺔ ﻟﻌﺪم وﺟﻮد ه ﺎ '‬ ‫داﺧﻞ وﺣﺪة ﺑﺮﳎﻴ ﺔ ‪' Module‬‬ ‫‪Dim X As Integer‬‬ ‫)( ‪Sub Test‬‬ ‫…‬ ‫…‬ ‫‪End Sub‬‬ ‫‪Module FirstProg‬‬ ‫…‬ ‫…‬ ‫‪End Module‬‬ ‫ﻴﻤﻜﻥ ﻟﻠﻤﻠﻑ ﺍﻟﻭﺍﺤﺩ ﺃﻥ ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﺍﻜﺜﺭ ﻤﻥ ﻭﺤﺩﺓ ﺒﺭﻤﺠﻴـﺔ، ﻓ ﻘـﺩ ﺘﺭﻏـﺏ –ﻤـﺜﻼ - ﻓـﻲ ﺘﻘﺴـﻴﻡ‬ ‫ﻭﺤﺩﺍﺘﻙ ﺍﻟﺒﺭﻤﺠﻴﺔ ﺍﺴﺘﻨﺎﺩﺍ ﺇﻟﻰ ﺘﺼﻨﻴﻑ ﻭﻅﺎﺌﻔﻬﺎ:‬ ‫‪Module DrawingFunctions‬‬ ‫…‬ ‫…‬ ‫‪End Module‬‬ ‫‪Module InternetFunctions‬‬ ‫…‬ ‫…‬ ‫‪End Module‬‬ ‫‪Module SystemFunctions‬‬ ‫…‬ ‫…‬ ‫‪End Module‬‬ ‫…‬ ‫…‬ ‫ﺒﺎﻟﻨﺴﺒﺔ ﻟﺸﺭﻭﻁ ﺘﺴﻤﻴﺔ ﺍﻟﻭﺤﺩﺍﺕ ﺍﻟﺒﺭﻤﺠﻴﺔ ﻓﻬﻲ ﻤﺜل ﺸﺭﻭﻁ ﺘﺴـﻤﻴﺔ ﺒـﺎﻗﻲ ﺍﻟﻤﻌﺭﻓـﺎﺕ ‪Identifiers‬‬ ‫ﺍﻻﺨﺭﻯ )ﻜﺎﻟﻤﺘﻐﻴﺭﺍﺕ، ﺍﻟﺘﺭﻜﻴﺒﺎﺕ، ﺍﻟﻔﺌﺎﺕ ...ﺍﻟﺦ( ﻭﻫﻲ:‬ ‫‪S‬‬ ‫ﺃﻥ ﻻ ﻴﺯﻴﺩ ﻋﺩﺩ ﺤﺭﻭﻑ ﺍﻟﻤﻌﺭﻑ ﻋﻥ 38361 ﺤﺭﻑ -ﻻ ﺍﻋﺘﻘﺩ ﺍﻨﻙ ﺒﺤﺎﺠـﺔ ﺍﻟـﻰ ﻜـل ﻫـﺫﺍ‬ ‫‪S‬‬ ‫ﺃﻥ ﻴﺒﺩﺃ ﺍﻟﻤﻌﺭﻑ ﺒﺤﺭﻑ ﺃﺒﺠﺩﻱ، ﻤﻊ ﺫﻟﻙ ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺸـﺭﻁﺔ ﺍﻟﺴـﻔﻠﻴﺔ "_" ﻜﺒﺩﺍﻴـﺔ ﻻﺴـﻡ‬ ‫ﺍﻟﻌﺩﺩ!‬ ‫ﺍﻟﻤﻌﺭﻑ ﻭﻟﻜﻥ ﻋﻠﻴﻙ ﺍﺘﺒﺎﻋﻬﺎ ﺒﺤﺭﻑ ﺃﺒﺠﺩﻱ ﻜﻲ ﻴﺘﻤﻜﻥ ﺍﻟﻤﺘﺭﺠﻡ ﻤﻥ ﺘﻤﻴﻴﺯﻫﺎ ﻋـﻥ ﺍﻟﻤﻌﺎﻤـل "_"‬ ‫)ﺍﻟﺫﻱ ﻴﺴﺘﺨﺩﻡ ﻟﺘﻘﺴﻴﻡ ﺍﻷﻤﺭ ﺇﻟﻰ ﺍﻜﺜﺭ ﻤﻥ ﺴﻁﺭ(.‬
  • 57.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫13‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫‪S‬‬ ‫ﻻ ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﺴﻡ ﻴﻤﺜل ﻜﻠﻤﺔ ﻤﺤﺠﻭﺯﺓ ‪ Keyword‬ﻟﺘﻌﺭﻴﻑ ﻤﻌﺭﻑ ﺠﺩﻴﺩ. ﻭﺍﻥ ﻜـﺎﻥ ﻻﺒـﺩ‬ ‫ﻤﻥ ﺫﻟﻙ، ﻓﺎﻜﺘﺏ ﺍﺴﻡ ﺍﻟﻤﻌﺭﻑ ﺩﺍﺨل ﺍﻟﻘﻭﺴـﻴﻥ ] ﻭ [ ) ﻤﺜـﺎل: ‪.( Dim [Dim] As Integer‬‬ ‫ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻘﻭﺴﻴﻥ ] ﻭ [ ﺃﻴﻀﺎ ﻟﺘﻌﺭﻴﻑ ﻤﻌﺭﻓﺎﺕ ﺃﺨﺭﻯ ﻏﻴﺭ ﺍﻟﻜﻠﻤﺎﺕ ﺍﻟﻤﺤﺠﻭﺯﺓ.‬ ‫ﹰ‬ ‫ﻣﻼﺣﻈﺔ‬ ‫ﺗﺴـﻤﺢ ﻟـﻚ ﻟﻐـﺔ اﻟﺒﺮﻣﺠـﺔ ‪ Visual Basic .NET‬ﺑﺎﺳـﺘﺨﺪام اﻟﺤـﺮوف اﻟﻌﺮﺑﻴـﺔ‬ ‫ﻟﻜﺘﺎﺑﺔ اﺳﻤﺎء اﻟﻤﻌﺮﻓﺎت، ﻓﻬﻲ داﻋﻤﺔ ﻟﺠﺪول اﻟﺮﻣﻮز ‪ ، UNICODE‬إﻻ أﻧﻨﻲ ﻟﻢ‬ ‫وﻟﻦ اﺳﺘﺨﺪﻣﻬﺎ ﻻ ﻓﻲ هﺬا اﻟﻜﺘﺎب وﻻ ﻓﻲ ﻣﺸﺎرﻳﻌﻲ اﻟﺨﺎ ﺻﺔ، ﻓﻼ اﻋﺘﻘﺪ اﻧﻚ‬ ‫ﺗﻮد رؤﻳﺔ ﺷﻴﻔﺮة ﻣﺸﺎﺑﻬﺔ ﻟﻠﺸﻴﻔﺮة اﻟﺘﺎﻟﻴﺔ :‬ ‫ﻓﺌﺔ ‪ A s New‬اﻟﻜﺎﺋﻦ ‪Dim‬‬ ‫‪ A s Integer‬س ‪Dim‬‬ ‫‪ = 23 Then‬ﺧﺎ ﺻﻴﺘﻪ.اﻟﻜﺎﺋﻦ ‪If‬‬ ‫0 = ﺧﺎ ﺻﻴﺘﻪ2.اﻟﻜﺎﺋﻦ = س‬ ‫‪End If‬‬ ‫)س ,02( ﻃﺮﻳﻘﺔ.آﺎﺋﻦ_ﻣﺤ ﻀﻮن.اﻟﻜﺎﺋﻦ‬ ‫ﺃﺨﻴﺭﹰ، ﻻ ﺘﺤﺎﻭل ﺘﻌﺭﻴﻑ ﺍﻜﺜﺭ ﻤﻥ ﻭﺤﺩﺓ ﺒﺭﻤﺠﻴﺔ ‪ Module‬ﺒﻨﻔﺱ ﺍﻻﺴﻡ ﻓﻲ ﺩﺍﺨل ﺍﻟﻤﺸـﺭﻭﻉ، ﺤﺘـﻰ‬ ‫ﺍ‬ ‫ﻭﺍﻥ ﺍﺨﺘﻠﻔﺕ ﺍﻟﻤﻠﻔﺎﺕ ﺍﻟﺘﺎﺒﻌﺔ ﻟﻬﺎ، ﻓﻬﺫﺍ ﻴﺴﺒﺏ ﺨﻁﺄ ﺘﻌﺎﺭﺽ ﺍﻷﺴﻤﺎﺀ :‬ ‫ﻟﻦ ﺗﺘﻢ ﺗ ﺮﲨﺔ ا ﻟﺸﻴﻔﺮ ة اﻟﺘ ﺎﻟﻴﺔ ﻟﺘﻌﺎر ض '‬ ‫اﺳﻢ اﻟ ﻮﺣﺪ ة ‪ MyModule‬ﰲ اﳌﻠﻔ ﲔ '‬ ‫ﰲ اﳌﻠ ﻒ ‪' First.vb‬‬ ‫‪Module MyModule‬‬ ‫…‬ ‫…‬ ‫‪End Module‬‬ ‫ﰲ اﳌﻠ ﻒ ‪' Second.vb‬‬ ‫‪Module MyModule‬‬ ‫…‬ ‫…‬ ‫‪End Module‬‬ ‫ﻣﻼﺣﻈﺔ‬ ‫ﻳﻤﻜﻨﻚ اﺳﺘﺨﺪام ﻧﻔﺲ اﻻﺳﻢ ﻟﺘﻌﺮﻳﻒ اآﺜﺮ ﻣﻦ وﺣﺪة ﺑﺮﻣﺠﻴﺔ ﺷﺮﻳﻄﺔ‬ ‫ﺗﻌﺮﻳﻔﻬﺎ ﻓﻲ ﻣﺠﺎﻻت اﺳﻤﺎء ‪ Namespaces‬ﻣﺨﺘﻠﻔﺔ. ﺳﺄﺗﻄﺮق اﻟﻰ ﻣﺠﺎﻻت‬ ‫اﻻﺳﻤﺎء ﻓﻲ اﻟﻘﺴﻢ اﻻﺧﻴﺮ ﻟ ﻬﺬا اﻟﻔ ﺼﻞ.‬
  • 58.
    ‫23‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫اﻹﺟﺮاء ‪Sub Main‬‬ ‫ﺘﺴﺘﻁﻴﻊ ﺘﻌﺭﻴﻑ ﻋﺩﺩ ﻏﻴﺭ ﻤﺤﺩﻭﺩ ﻤﻥ ﺍﻻﺠﺭﺍﺀﺍﺕ ﻓﻲ ﺩﺍﺨل ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ ‪ Module‬ﺒﻤﺎ ﻟﺫ ﻭﻁـﺎﺏ ﻟـﻙ‬ ‫ﻤﻥ ﺍﻻﺴﻤﺎﺀ ﺍﻟﺘﻲ ﺘﺭﻴﺩﻫﺎ، ﺍﻻ ﺍﻥ ﺍﻻﺠﺭﺍﺀ ﺍﻟﺫﻱ ﻴﺤﻤل ﺍﻻﺴﻡ ‪ Main‬ﻟﻪ ﻁـﺎﺒﻊ ﺨـﺎﺹ، ﻓﻬـﻭ ﻴﻤﻜﻨـﻙ ﻤـﻥ‬ ‫ﺘﺨﺼﻴﺹ ﺍﻟﻤﺘﺭﺠﻡ ﻟﻴﻘﻭﻡ ﺒﺎﺴﺘﺩﻋﺎﺀ ﻫﺫﺍ ﺍﻻﺠﺭﺍﺀ ﻤﻊ ﺒﺩﺍﻴﺔ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ:‬ ‫1‪Module Module‬‬ ‫)(‪Sub Main‬‬ ‫‪A‬‬ ‫)"ﺑﺪاﻳ ﺔ اﻟﱪ ﻧﺎﻣﺞ ﻣﻦ هﻨ ﺎ"(‪ِ rabicConsole.WriteLine‬‬ ‫‪End Sub‬‬ ‫‪End Module‬‬ ‫ﺍﻟﻤﺯﻴﺩ ﺍﻴﻀﺎ، ﺘﺴﺘﻁﻴﻊ ﺘﻌﺭﻴﻑ ﺍﻜﺜﺭ ﻤﻥ ﺍﺠﺭﺍﺀ ‪ Main‬ﻓﻲ ﺍﻜﺜﺭ ﻤﻥ ﻭﺤﺩﺓ ﺒﺭﻤﺠﻴﺔ:‬ ‫1‪Module Module‬‬ ‫)(‪Sub Main‬‬ ‫)"ﻣﻦ ا ﻟﻮﺣﺪة اﻟﱪﳎ ﻴﺔ اﻻ و ﱃ"(‪ArabicConsole.WriteLine‬‬ ‫‪End Sub‬‬ ‫‪End Module‬‬ ‫2‪Module Module‬‬ ‫)(‪Sub Main‬‬ ‫)"ﻣﻦ ا ﻟﻮﺣﺪة اﻟﱪﳎ ﻴﺔ اﻟ ﺜﺎﻧﻴ ﺔ"(‪ArabicConsole.WriteLine‬‬ ‫‪End Sub‬‬ ‫‪End Module‬‬ ‫ﻭﺍﻟﺴﺅﺍل ﺍﻟﺫﻱ ﻴﻁﺭﺡ ﻨﻔﺴﻪ، ﺃﻱ ﻤﻥ ﺍﻻﺠﺭﺍﺌﻴﻥ ‪ Main‬ﺍﻟﺴﺎﺒﻘﻴﻥ ﺴﻴﺘﻡ ﺍﺴﺘﺩﻋﺎﺌﻪ ﻤﻊ ﺒﺩﺍﻴـﺔ ﺘﻨﻔﻴـﺫ ﺍﻟﺒﺭﻨـﺎﻤﺞ؟‬ ‫ﻭﺍﻟﺠﻭﺍﺏ ﻫﻭ ﻜﺎﺌﻥ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺫﻱ ﺘﺤﺩﺩﻩ ﻓـﻲ ﺨﺎﻨـﺔ ‪ Startup Object‬ﻤـﻥ ﻨﺎﻓـﺫﺓ ‪Project Property‬‬ ‫‪) Pages‬ﺸﻜل 2 -1(. ﺴﺘﻅﻬﺭ ﺭﺴﺎﻟﺔ ﺨﻁﺄ ﺍﺫﺍ ﺍﺨﺘﺭﺕ ﻭﺤﺩﺓ ﺒﺭﻤﺠﻴﺔ ‪ Module‬ﻟﻡ ﻴﻌـﺭﻑ ﺒﻬـﺎ ﺍﺠـﺭﺍﺀ‬ ‫ﺒﺎﺴﻡ ‪ ،Main‬ﻜﻤﺎ ﺴﺘﻅﻬﺭ ﻨﻔﺱ ﺭﺴﺎﻟﺔ ﺍﻟﺨﻁﺄ ﺍﻥ ﺤـﺩﺩﺕ ﺍﻻﺨﺘﻴـﺎﺭ ‪) Sub Main‬ﺍﻟﻤﻭﺠـﻭﺩ ﻓـﻲ ﻨﻔـﺱ‬ ‫ﺍﻟﻘﺎﺌﻤﺔ( ﺍﻥ ﻭﺠﺩ ﺍﻻﺠﺭﺍﺀ ‪ Main‬ﻓﻲ ﺍﻜﺜﺭ ﻤﻥ ﻭﺤﺩﺓ ﺒﺭﻤﺠﻴﺔ ﺍﻭ ﻟﻡ ﻴﺘﻡ ﺘﻌﺭﻴﻔﻪ ﻓﻲ ﺍﻱ ﻭﺤﺩﺓ ﺒﺭﻤﺠﻴﺔ.‬ ‫ﺸﻜل 2 -1: ﺘﺤﺩﻴﺩ ﺍﻻﺠﺭﺍﺀ ﺍﻻﺒﺘﺩﺍﺌﻲ ﻟﻠﻤﺸﺭﻭﻉ.‬
  • 59.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫33‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫اﻻﺟﺮاء ‪Sub New‬‬ ‫ﺍﺠﺭﺍﺀ ﺍﺨﺭ ﻟﻪ ﻁـﺎﺒﻊ ﺨـﺎﺹ ﻴﺤﻤـل ﺍﻻﺴـﻡ ‪ ،New‬ﻴﻌـﺭﻑ ﻫـﺫﺍ ﺍﻟﻨـﻭﻉ ﻤـﻥ ﺍﻻﺠـﺭﺍﺀﺍﺕ ﺒﺎﻟﻤﺸـﻴﺩ‬ ‫‪ ،Constructor‬ﻭﻫﻭ ﻋﺒﺎﺭﺓ ﻋﻥ ﺍﺠﺭﺍﺀ ﻴﺘﻡ ﺘﻨﻔﻴﺫﻩ ﺒﻤﺠﺭﺩ ﺍﻨﺸﺎﺀ ﻨﺴﺨﺔ ﻤﻥ ﺍﻟﻜﺎﺌﻥ ﺍﻟﺘـﺎﺒﻊ ﻟـﻪ. ﻓﻠـﻭ ﻜﺎﻨـﺕ‬ ‫ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻫﻲ ﺍﻭل ﻭﺤﺩﺓ ﻴﺘﻡ ﺘﻨﻔﻴﺫﻫﺎ ﻓﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ، ﻓﺴﻴﺘﻡ ﺘﻨﻔﻴﺫ ﺍﻻﺠﺭﺍﺀ ‪ New‬ﻗﺒل ‪:Main‬‬ ‫1‪Module Module‬‬ ‫)(‪Sub New‬‬ ‫)"ﺳﻴﺘﻢ ﺗ ﻨﻔﻴﺬ اﳌﺸﻴ ﺪ ‪ New‬او ﻻ"(‪ArabicConsole.WriteLine‬‬ ‫‪End Sub‬‬ ‫)(‪Sub Main‬‬ ‫)"ﰒ ﺗﻨ ﻔﻴﺬ ا ﻻﺟﺮاء اﻟﺮﺋ ﻴﺴ ﻲ ‪ArabicConsole.WriteLine("Main‬‬ ‫‪End Sub‬‬ ‫‪End Module‬‬ ‫اﻧﻈﺮ اﻳﻀﺎ‬ ‫ﺗﺠﺪ اﻟﻤﺰﻳﺪ ﻣﻦ اﻟﺘﻔﺎ ﺻﻴﻞ واﻟﺘﻄﺒﻴﻘﺎت ﺣﻮل اﻟﻤﺸﻴﺪات ‪ Constructors‬ﻓﻲ‬ ‫اﻟﻔ ﺼﻞ اﻟﺮاﺑﻊ اﻟﻔﺌﺎت واﻟ ﻜﺎﺋﻨﺎت .‬ ‫ﻋﻠﻴﻙ ﻤﻌﺭﻓﺔ ﺍﻥ ﺍﻟﻤﺸﻴﺩﺍﺕ ﻓﻲ ﺍﻟﻭﺤﺩﺍﺕ ﺍﻟﺒﺭﻤﺠﻴـﺔ ﻻ ﻴـﺘﻡ ﺘﻨﻔﻴـﺫﻫﺎ ﺍﻻ ﺍﻥ ﻗﻤـﺕ ﺒﺎﺴـﺘﺩﻋﺎﺀ ﺍﺤـﺩ‬ ‫ﺍﺠﺭﺍﺀﺍﺕ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ ﺍﻭ ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﺍﺤﺩ ﻤﺘﻐﻴﺭﺍﺘﻬـﺎ، ﻓﺎﻟﻤﺸـﻴﺩ ﺍﻟﻤﻭﺠـﻭﺩ ﻓـﻲ ﺍﻟﻭﺤـﺩﺓ ﺍﻟﺒﺭﻤﺠﻴـﺔ‬ ‫2‪ Module‬ﺍﻟﺘﺎﻟﻴﺔ ﻟﻥ ﻴﺘﻡ ﺘﻨﻔﻴﺫﻩ، ﻭﺫﻟﻙ ﻻﻨﻨﺎ ﻟﻡ ﻨﺴﺘﺨﺩﻡ ﺍﻱ ﻋﻀﻭ ﻤﻥ ﺍﻋﻀـﺎﺀ ﺍﻟﻭﺤـﺩﺓ ﺍﻟﺒﺭﻤﺠﻴـﺔ ﺍﻟﺘﺎﺒﻌـﺔ‬ ‫ﻟﻪ:‬ ‫1‪Module Module‬‬ ‫)(‪Sub New‬‬ ‫)"ﺳﻴﺘﻢ ﺗ ﻨﻔﻴﺬ اﳌﺸﻴ ﺪ ‪ New‬او ﻻ"(‪ArabicConsole.WriteLine‬‬ ‫‪End Sub‬‬ ‫)(‪Sub Main‬‬ ‫)"ﰒ ﺗﻨ ﻔﻴﺬ ا ﻻﺟﺮاء اﻟﺮﺋ ﻴﺴ ﻲ ‪ArabicConsole.WriteLine("Main‬‬ ‫‪End Sub‬‬ ‫‪End Module‬‬ ‫2‪Module Module‬‬ ‫)(‪Sub New‬‬ ‫)"ﻟﻦ ﻳ ﺘﻢ ﺗﻨ ﻔﻴﺬ ه ﺬا اﳌ ﺸﻴ ﺪ"(‪ArabicConsole.WriteLine‬‬ ‫‪End Sub‬‬ ‫‪End Module‬‬
  • 60.
    ‫43‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫اﻟﻤﺘﻐﻴﺮات واﻟﺜﻮاﺑﺖ‬ ‫ﻻ ﻴﺨﺘﻠﻑ ﻤﺒﺭﻤﺠﺎﻥ ﺍﺜﻨﺎﻥ ﻋﻠﻰ ﺍﻫﻤﻴﺔ ﻤﻭﻀﻭﻉ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻓﻲ ﺃﻱ ﻟﻐﺔ ﺒﺭﻤﺠـﺔ، ﻭﺇﺫﺍ ﻜـﺎﻥ ﺃﺴـﺎﺱ ﺇﺘﻘـﺎﻥ‬ ‫ﺍﻟﻠﻐﺎﺕ ﺍﻟﻁﺒﻴﻌﻴﺔ ﻫﻭ ﺘﻌﻠﻡ ﺤﺭﻭﻑ ﻭﻤﻔﺭﺩﺍﺕ ﺘﻠﻙ ﺍﻟﻠﻐﺔ، ﻓﺎﻥ ﺍﺴﺎﺱ ﺍﺘﻘﺎﻥ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﻫﻭ ﺘﻌﻠﻡ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ‬ ‫ﻭﺍﻟﺜﻭﺍﺒﺕ ﺍﻟﺘﻲ ﺘﺒﻨﻲ ﺒﻬﺎ ﺍﺠﺭﺍﺀﺍﺕ ﺒﺭﺍﻤﺠﻙ. ﻨﻅﺭﻴﺎ، ﻻ ﺘﺨﺘﻠـﻑ ﻓﻜـﺭﺓ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﻓـﻲ ‪Visual Basic‬‬ ‫‪ .NET‬ﻋﻥ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻘﺩﻴﻤﺔ، ﻭﻟﻜﻨﻬﺎ ﺘﺨﺘﻠﻑ ﺍﺨﺘﻼﻓﺎ ﺠﺫﺭﻴﺎ ﻓﻲ ﺒﻨﻴﺘﻬﺎ ﺍﻟﺘﺤﺘﻴﺔ ﻋﻤﺎ ﻜﺎﻨـﺕ ﻋﻠﻴـﻪ ﻓـﻲ‬ ‫ﹰ‬ ‫ﹰ‬ ‫ﺍﻟﺴﺎﺒﻕ ﻜﻤﺎ ﺴﺘﺭﻯ ﻻﺤﻘﺎ.‬ ‫اﻟﺘﺼﺮﻳﺢ ﻋﻦ اﻟﻤﺘﻐﻴﺮات‬ ‫ﻤﺎ ﺯﺍﻟﺕ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Dim‬ﺘﺴﺘﺨﺩﻡ ﻟﻠﺘﺼﺭﻴﺢ ﻋﻥ ﻤﺘﻐﻴﺭ ﺠﺩﻴﺩ ﺒﺭﻓﻘﺔ ﺍﻟﻤﻌﺎﻤل ‪ As‬ﺍﻟـﺫﻱ ﻴﺤـﺩﺩ ﻨـﻭﻉ‬ ‫ﺍﻟﻤﺘﻐﻴﺭ:‬ ‫ﻣﺘﻐﲑ ﻣ ﻦ اﻟﻨ ﻮ ع ‪' Integer‬‬ ‫‪Dim Age As Integer‬‬ ‫ﻣﺘﻐﲑا ن ﻣﻦ اﻟﻨﻮ ع ‪' String‬‬ ‫‪Dim FirstName As String‬‬ ‫‪Dim LastName As String‬‬ ‫ﻓﻲ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ ﻋﺭﻓﺕ ﻤﺘﻐﻴﺭﻴﻥ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ String‬ﻓﻲ ﺴﻁﺭﻴﻥ ﻤﻨﻔﺼﻠﻴﻥ، ﻤﻊ ﺫﻟـﻙ ﻴﻤ ﹼﻨـﻙ ‪Visual‬‬ ‫ﻜ‬ ‫‪ Basic .NET‬ﻤﻥ ﺩﻤﺠﻬﻤﺎ ﻓﻲ ﺴﻁﺭ ﻭﺍﺤﺩ:‬ ‫‪Dim Age As Integer‬‬ ‫‪Dim FirstName, LastName As String‬‬ ‫ﺍﻭ ﺩﻤﺞ ﺘﺼﺎﺭﻴﺢ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﺜﻼﺜﺔ ﻜﻠﻬﺎ ﻓﻲ ﺴﻁﺭ ﻭﺍﺤﺩ –ﺒﺎﻟﺭﻏﻡ ﻤﻥ ﺍﺨﺘﻼﻑ ﺍﻨﻭﺍﻋﻬﺎ:‬ ‫ﻻ اﻧﺼﺤﻚ ﺑﺘﻌﺮﻳ ﻒ اﻧﻮ اع ﳐﺘ ﻠﻔﺔ ﻣ ﻦ '‬ ‫اﳌﺘﻐﲑات ﰲ ﺳﻄﺮ واﺣ ﺪ '‬ ‫‪Dim FirstName, LastName As String, Age As Integer‬‬ ‫ﻴﻨﺼﺢ ﺩﺍﺌﻤﺎ ﺒﺘﺤﺩﻴﺩ ﻨﻭﻉ ﺍﻟﻤﺘﻐﻴﺭ ﻋﻨﺩ ﺍﻟﺘﺼﺭﻴﺢ ﻋﻨﻪ، ﻭﺍﻥ ﻟﻡ ﺘﺤـﺩﺩ ﻨـﻭﻉ ﺍﻟﻤﺘﻐﻴـﺭ ﻓﺴـﻴﻜﻭﻥ ﻨﻭﻋـﻪ‬ ‫ﺒﺸﻜل ﻤﺒﺩﺌﻲ ‪ ،Object‬ﻭﺴﻴﺘﻡ ﺘﺤﻭﻴﻠﻪ ﺍﻟﻰ ﻨﻭﻉ ﺍﺨﺭ ﺘﻤﺎﺜل ﻨﻭﻉ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺘﻲ ﺘﺴﻨﺩﻫﺎ ﺍﻟﻴﻪ:‬ ‫‪Dim X‬‬ ‫اﺻﺒﺢ اﳌﺘﻐﲑ هﻨﺎ ﻣﻦ اﻟ ﻨﻮ ع ‪' Integer‬‬ ‫وهﻨﺎ اﺻﺒ ﺢ ‪' String‬‬ ‫01 = ‪X‬‬ ‫"01" = ‪X‬‬ ‫ﻤﻊ ﺍﻥ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﺴﺎﺒﻘﺔ ﺘﻌﻁﻴﻙ ﻤﺭﻭﻨﺔ ﻜﺒﻴﺭﺓ ﻓﻲ ﺘﺸﻜﻴل ﻭﺘﻐﻴﻴﺭ ﻨﻭﻉ ﺍﻟﻤﺘﻐﻴﺭ ﻤـﻥ ﻭﻗـﺕ ﻻﺨـﺭ، ﺍﻻ ﺍﻨﻬـﺎ‬ ‫ﺘﺴﺒﺏ ﺒﻁﺌﺎ ﻜﺒﻴﺭﺍ ﻓﻲ ﻋﻤﻠﻴﺔ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ، ﻭﺍﻟﺴﺒﺏ ﻫﻭ ﺍﻀﻁﺭﺍﺭ ﺍﻟﻤﺘـﺭﺠﻡ ﺍﻟـﻰ ﺍﻟﻘﻴـﺎﻡ ﺒﺠﻬـﺩ ﺍﻀـﺎﻓﻲ‬ ‫ﹰ‬ ‫ﹰ‬ ‫ﻟﺘﺤﻭﻴل ﻨﻭﻉ ﺍﻟﻤﺘﻐﻴﺭ.‬
  • 61.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫53‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺍﻟﻌﺒﺎﺭﺓ ‪:Option Explicit‬‬ ‫ﻤﺒﺩﺌﻴﺎ، ﻋﻤﻠﻴﺔ ﺍﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺃﻤﺭ ﺍﻟﺯﺍﻤﻲ ﻋﻠﻴﻙ ﻗﺒل ﺍﺴـﺘﺨﺩﺍﻡ ﺍﻟﻤﺘﻐﻴـﺭ، ﺍﻤـﺎ ﺍﻥ ﻜﺎﻨـﺕ ﺍﻟﻌﺒـﺎﺭﺓ‬ ‫‪ Option Explicit Off‬ﻤﺴﻁﻭﺭﺓ ﻓﻲ ﺍﻋﻠﻰ ﺍﻟﻤﻠﻑ، ﻓﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻭﺍﻟﺘﻌﺎﻤل ﻤﻌﻬـﺎ ﻤﺒﺎﺸـﺭﺓ‬ ‫ﺩﻭﻥ ﺍﻟﺤﺎﺠﺔ ﻟﻠﺘﺼﺭﻴﺢ ﻋﻨﻬﺎ ﺒـ ‪:Dim‬‬ ‫‪Option Explicit Off‬‬ ‫1‪Module Module‬‬ ‫)(‪Sub Main‬‬ ‫ﻣﺘﻐﲑ ﺟ ﺪﻳﺪ ا ﺳﺘﺨﺪﻣ ﺘﻪ ﻣﺒ ﺎﺷﺮ ة '‬ ‫دون ﺗ ﻌﺮﻳﻔﻪ ﺑ ـ ‪' Dim‬‬ ‫"ﺗﺮآﻲ اﻟ ﻌﺴﲑ ي" = ‪programmerName‬‬ ‫) ‪ArabicConsole.Writeline ( programmerName‬‬ ‫‪End Sub‬‬ ‫‪End Module‬‬ ‫ﺼﺤﻴﺢ ﺍﻥ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ ﺴﺘﻭﻓﺭ ﻋﻠﻴﻙ ﻋﻨﺎﺀ ﺍﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ، ﺇﻻ ﺃﻥ ﻫﺫﺍ ﺍﻷﺴـﻠﻭﺏ ﻏﻴـﺭ ﻤﺤﺒـﺫ‬ ‫ﺒﺸﻜل ﻜﺒﻴﺭ ﻟﺩﻯ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺍﻟﺠﺎﺩﻴﻥ، ﺍﻻﺨﻁﺎﺀ ﺍﻻﻤﻼﺌﻴﺔ ﻫﻲ ﺍﺤﺩ ﺍﻻﺴﺒﺎﺏ:‬ ‫ﳐﺮﺟﺎت اﻻ ﻣﺮ اﻟ ﺘﺎﱄ ﻻ ﺷﺊ ﺑ ﺴﺒﺐ ا ﳋﻄﺄ ا ﻻﻣﻼﺋﻲ ﰲ '‬ ‫آﺘﺎﺑﺔ اﺳ ﻢ اﳌﺘ ﻐﲑ اﻟ ﺴﺎﺑ ﻖ '‬ ‫) ‪ArabicConsole.Writeline ( programerName‬‬ ‫ﺴﺒﺏ ﺍﺨﺭ ﻗﺩ ﻴﺠﻌﻠﻙ ﺘﺭﻓﺽ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻌﺒﺎﺭﺓ ‪ Option Explicit Off‬ﻭﻫﻭ ﺍﻥ ﺠﻤﻴـﻊ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ‬ ‫ﺴﺘﻜﻭﻥ ﺒﺸﻜل ﺍﺒﺘﺩﺍﺌﻲ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Object‬ﻭﻓﻲ ﻜل ﻤﺭﺓ ﺘﺴﻨﺩ ﻗﻴﻤﺔ ﺠﺩﻴﺩﺓ ﺴﻴﺘﻡ ﺘﺤﻭﻴـل ﻨـﻭﻉ ﺍﻟﻤﺘﻐﻴـﺭ ﺍﻟـﻰ‬ ‫ﺍﻟﻨﻭﻉ ﺍﻟﻤﻤﺎﺜل ﻟﻠﻘﻴﻤﺔ ﺍﻟﻤﺴﻨﺩﺓ ﺍﻟﻴﻪ، ﻤﻤﺎ ﻴﺴﺒﺏ ﺒﻁﺌﺎ ﻓﻲ ﻋﻤﻠﻴﺔ ﺍﻟﺘﻨﻔﻴﺫ.‬ ‫ﹰ‬ ‫ﻋﻠﻴﻙ ﺍﻻﺨﺫ ﺒﻌﻴﻥ ﺍﻻﻋﺘﺒﺎﺭ ﺍﻥ ﺘﺄﺜﻴﺭ ﺍﻟﻌﺒﺎﺭﺓ ‪ Option Explicit Off‬ﻴﺸﻤل ﺍﻟﻤﻠـﻑ ﺍﻟﺤـﺎﻟﻲ ﺍﻟـﺫﻱ‬ ‫ﺴﻁﺭﺕ ﻓﻴﻪ ﺍﻟﻌﺒﺎﺭﺓ ﻓﻘﻁ. ﻭﺒﺩﻻ ﻤﻥ ﻜﺘﺎﺒﺘﻬﺎ ﻓﻲ ﻜﺎﻓﺔ ﻤﻠﻔﺎﺕ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻻﺨﺭﻯ، ﻴﻤﻜﻨﻙ ﺍﺨﺘﻴـﺎﺭ ﺍﻟﻘﻴﻤـﺔ ‪Off‬‬ ‫ﻤﻥ ﻗﺎﺌﻤﺔ ‪ Option Explicit‬ﻓﻲ ﺨﺎﻨﺔ ﺍﻟﺘﺒﻭﻴـﺏ ‪ Build‬ﻤـﻥ ﻨﺎﻓـﺫﺓ ﺨﺼـﺎﺌﺹ ﺍﻟﻤﺸـﺭﻭﻉ ‪Project‬‬ ‫‪) Property Pages‬ﺸﻜل 2 -2(.‬
  • 62.
    ‫63‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺸﻜل 2 -2: ﺘﻐﻴﻴﺭ ﻗﻴﻤﺔ ‪ Option Explicit‬ﻤﻥ ‪ On‬ﺍﻟﻰ ‪.Off‬‬ ‫ﻗﺎﺑﻠﻴﺔ اﻟﺮؤﻳﺔ وﻋﻤﺮ اﻟﻤﺘﻐﻴﺮات‬ ‫ﻗﺎﺒﻠﻴﺔ ﺍﻟﺭﺅﻴﺔ ‪ Visibility‬ﺍﻭ ﺍﻟﻤﺩﻯ ‪ Scope‬ﻟﻠﻤﺘﻐﻴﺭ ﺘﻤﺜل ﻗﺩﺭﺓ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻋﻠـﻰ ﺍﻟﻭﺼـﻭل ﺍﻟـﻰ ﺍﻟﻤﺘﻐﻴـﺭ‬ ‫ﻭﺍﺴﺘﺨﺩﺍﻤﻪ، ﻓﺎﻟﻤﺘﻐﻴﺭ ‪ X‬ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ ﺍﻻﺠﺭﺍﺀ 1‪ MySub‬ﺍﻟﺘﺎﻟﻲ، ﻻ ﻴﻤﻜﻨﻙ ﺍﻟﻭﺼﻭل ﺍﻟﻴﻪ ﻭﺍﺴـﺘﺨﺩﺍﻤﻪ ﻤـﻥ‬ ‫ﺨﺎﺭﺝ ﺍﻻﺠﺭﺍﺀ:‬ ‫)( 1‪Sub MySub‬‬ ‫‪Dim X As Integer‬‬ ‫02 = ‪X‬‬ ‫‪End Sub‬‬ ‫)( 2‪Sub MySub‬‬ ‫ﻻ ﳝﺜ ﻞ اﳌﺘ ﻐ ﲑ ‪ X‬اﻟﺴﺎﺑ ﻖ '‬ ‫)‪ArabicConsole.WriteLine (X‬‬ ‫‪End Sub‬‬ ‫ﺍﻤﺎ ﻋﻤﺭ ‪ Lifetime‬ﺍﻟﻤﺘﻐﻴﺭ، ﻓﺘﻤﺜل ﺍﻟﻔﺘﺭﺓ ﺍﻟﺘﻲ ﻴﻅل ﻓﻴﻬﺎ ﺍﻟﻤﺘﻐﻴﺭ ﻤﺤﺘﻔﻅـﺎ ﺒﻘﻴﻤﺘـﻪ، ﻓـﺎﻟﻤﺘﻐﻴﺭ ‪X‬‬ ‫ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ، ﺴﻴﻨﺘﻬﻲ ﻭﻴﻔﻘﺩ ﺍﻟﻘﻴﻤﺔ 02 ﺍﻟﺘﻲ ﻜﺎﻥ ﻤﺤﺘﻔﻅﺎ ﺒﻬﺎ ﺒﻤﺠـﺭﺩ ﺍﻻﻨﺘﻬـﺎﺀ ﻤـﻥ ﺘﻨﻔﻴـﺫ‬ ‫ﺍﻻﺠﺭﺍﺀ 1‪ .MySub‬ﻭﺤﺘﻰ ﺘﻔﻬﻡ ﺍﻻﺴﻠﻭﺏ ﺍﻟﺫﻱ ﻴﺘﺒﻌﻪ ‪ Visual Basic .NET‬ﻟﺘﻁﺒﻴﻕ ﻤﻔﻬـﻭﻤﻲ ﻗﺎﺒﻠﻴـﺔ‬ ‫ﺍﻟﺭﺅﻴﺔ ﻭﺍﻟﻌﻤﺭ ﻟﻠﻤﺘﻐﻴﺭ، ﻋﻠﻴﻙ ﻤﻌﺭﻓﺔ ﺍﻨﻭﺍﻉ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻤﻥ ﻤﻨﻅﻭﺭ ﺍﻟﺭﺅﻴﺔ ﻭﺍﻟﻌﻤﺭ:‬ ‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺤﻠﻴﺔ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴﺔ:‬ ‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺤﻠﻴﺔ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴﺔ ‪ Dynamic Local Variables‬ﻫﻲ ﻤﺘﻐﻴﺭﺍﺕ ﻴﺘﻡ ﺍﻻﻋـﻼﻥ ﻋﻨﻬـﺎ ﺩﺍﺨـل‬ ‫ﺍﻻﺠﺭﺍﺀﺍﺕ، ﻭﻋﻤﺭ ﺍﻟﻤﺘﻐﻴﺭ ﻴﺒﺩﺃ ﻤﻥ ﺍﻟﺴﻁﺭ ﺍﻟﺫﻱ ﺘﺼﺭﺡ ﻓﻴﻪ ﻋﻥ ﺍﻟﻤﺘﻐﻴﺭ ﻭﻴﻨﺘﻬﻲ ﺒﻌﺩ ﺍﻻﻨﺘﻬـﺎﺀ ﻤـﻥ ﺘﻨﻔﻴـﺫ‬ ‫ﺍﻻﺠﺭﺍﺀ. ﺍﻤﺎ ﺒﺎﻟﻨﺴﺒﺔ ﻟﻘﺎﺒﻠﻴﺔ ﺍﻟﺭﺅﻴﺔ ﻓﻬﻲ ﻤﺤﺼﻭﺭﺓ ﺩﺍﺨل ﺍﻻﺠﺭﺍﺀ ﺍﻟﺫﻱ ﺼﺭﺤﺕ ﻓﻴﻪ ﻓﻘﻁ. ﺘﺴـﺘﺨﺩﻡ ﺍﻟﻜﻠﻤـﺔ‬ ‫ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Dim‬ﺍﻴﻀﺎ ﻟﻠﺘﺼﺭﻴﺢ ﻋﻥ ﻤﺘﻐﻴﺭ ﻤﺤﻠﻲ ﺩﻴﻨﺎﻤﻴﻜﻲ.‬
  • 63.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫73‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺘﻘﺘﺭﺡ ﻋﻠﻴﻙ ﻤﺴﺘﻨﺩﺍﺕ ‪ Microsoft .NET‬ﺍﺴﺘﺨﺩﺍﻡ ﺍﺴﻠﻭﺏ ﻴﺴﻤﻰ ‪ smallCase‬ﻓﻲ ﺘﺴـﻤﻴﺔ ﻫـﺫﺍ‬ ‫ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ، ﺒﺤﻴﺙ ﺘﻜﻭﻥ ﺍﻟﻜﻠﻤﺔ ﺍﻻﻭﻟﻰ ﺼﻐﻴﺭﺓ ﺍﻟﺤﺭﻭﻑ ‪ small‬ﻭﺍﻟﺤـﺭﻑ ﺍﻻﻭل ﻤـﻥ ﺍﻟﻜﻠﻤـﺎﺕ‬ ‫ﺍﻻﺨﺭﻯ ﻜﺒﻴﺭ ‪ .Capital‬ﺍﻤﺜﻠﺔ:‬ ‫‪Dim programmerName As String‬‬ ‫‪Dim userID as Integer‬‬ ‫‪Dim employeeSalary As Decimal‬‬ ‫ﺒﻌﻴﺩﺍ ﻋﻥ ﻤﻭﻀﻭﻉ ﺍﻟﺘﺴﻤﻴﺔ، ﻴﻭﺠﺩ ﻨﻭﻉ ﺨﺎﺹ ﻤﻥ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺍﻟﻤﺤﻠﻴـﺔ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴـﺔ ﻴﻌـﺭﻑ ﺒﺎﻟــ‬ ‫‪ ،Block level Variables‬ﻭﻫﻲ ﻤﺘﻐﻴﺭﺍﺕ ﻴﺘﻡ ﺘﻌﺭﻴﻔﻬﺎ ﺩﺍﺨل ﺘﺭﻜﻴﺏ ‪) Block‬ﻜﺤﻠﻘـﺔ ‪،For … Next‬‬ ‫ﺠﻤﻠﺔ ‪ ،If … Then‬ﺤﻠﻘﺔ ‪ Do … Loop‬ﻭﻏﻴﺭﻫﺎ(. ﻤﺩﻯ ﻫـﺫﻩ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﻴﻜـﻭﻥ ﻤﺤﺼـﻭﺭﺍ ﺩﺍﺨـل‬ ‫ﹰ‬ ‫ﺍﻟﺘﺭﻜﻴﺏ ﺍﻟﺫﻱ ﺍﻋﻠﻨﺕ ﻓﻴﻪ ﻋﻥ ﺍﻟﻤﺘﻐﻴﺭ، ﻭﻋﻤﺭﻫﺎ ﻤﺜل ﻋﻤﺭ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺤﻠﻴـﺔ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴـﺔ ﺍﻟﺴـﺎﺒﻘﺔ. ﻫـﺫﺍ‬ ‫ﻤﺘﻐﻴﺭ ﻴﺤﻤل ﺍﻻﺴﻡ ‪ y‬ﻋﺭﻑ ﺩﺍﺨل ﺤﻠﻘﺔ ‪:For … Next‬‬ ‫‪Dim counter As Integer‬‬ ‫01 ‪For counter = 1 To‬‬ ‫‪Dim y as integer‬‬ ‫…‬ ‫…‬ ‫‪Next‬‬ ‫ﻻ ﺘﺤﺎﻭل ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﺘﻐﻴﺭ ﺍﻟﻤﻌﺭﻑ ﻓﻲ ﺩﺍﺨل ﺘﺭﻜﻴﺏ ﺨﺎﺭﺝ ﻫﺫﺍ ﺍﻟﺘﺭﻜﻴﺏ، ﻓﻤﺩﻯ ﻫـﺫﺍ ﺍﻟﻨـﻭﻉ ﻤـﻥ‬ ‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ –ﻜﻤﺎ ﻗﻠﺕ - ﻤﺤﺼﻭﺭ ﺩﺍﺨل ﺍﻟﺘﺭﻜﻴﺏ ﻓﻘﻁ:‬ ‫‪Dim x As Integer‬‬ ‫‪If x = 0 Then‬‬ ‫‪Dim y As Integer‬‬ ‫…‬ ‫…‬ ‫‪End If‬‬ ‫رﺳﺎﻟﺔ ﺧ ﻄ ﺄ '‬ ‫‪x = y‬‬ ‫ﻜﻤﺎ ﺃﻨﻙ ﻻ ﺘﺴﺘﻁﻴﻊ ﺍﺴﺘﺨﺩﺍﻡ ﺍﺴﻡ ﻤﺘﻐﻴﺭ ﺩﻴﻨﺎﻤﻴﻜﻲ ﻤﺤﻠﻲ ﻟﺘﺴﻤﻲ ﺒﻪ ﻤﺘﻐﻴﺭ ﺩﺍﺨل ﺘﺭﻜﻴـﺏ ﻓـﻲ ﻨﻔـﺱ‬ ‫ﺍﻻﺠﺭﺍﺀ:‬ ‫‪Dim a As Integer‬‬ ‫رﺳﺎﻟﺔ ﺧ ﻄ ﺄ '‬ ‫‪Dim a as integer‬‬ ‫…‬ ‫…‬ ‫‪Do‬‬ ‫‪Loop‬‬
  • 64.
    ‫83‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻤﻊ ﺫﻟﻙ، ﻴﺴﻤﺢ ﻟﻙ ‪ Visual Basic .NET‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﻨﻔﺱ ﺍﺴﻤﺎﺀ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺍﻟﻌﺎﻤـﺔ ﺍﻭ ﻋﻠـﻰ ﻤﺴـﺘﻭﻯ‬ ‫ﺍﻟﻭﺤﺩﺓ ﺍﻭ ﺤﺘﻰ ﺍﺴﻤﺎﺀ ﻤﺘﻐﻴﺭﺍﺕ ﺍﺨﺭﻯ ﻤﻌﺭﻓﺔ ﻓﻲ ﺘﺭﻜﻴﺏ ﺁﺨﺭ:‬ ‫اﻓﱰض اﻧﻪ ﻣﺘﻐﲑ ﻋﻠﻰ ﻣﺴﺘﻮى اﻟﻮﺣ ﺪة او ﻋﺎ م '‬ ‫‪Dim x As Integer‬‬ ‫…‬ ‫…‬ ‫ﳑﻜﻦ ﺟﺪ ا '‬ ‫ﺧﺬ راﺣ ﺘ ﻚ '‬ ‫‪If x = 0 Then‬‬ ‫‪Dim x As String‬‬ ‫…‬ ‫…‬ ‫‪End If‬‬ ‫‪Dim x As Long‬‬ ‫…‬ ‫…‬ ‫‪Do‬‬ ‫‪Loop‬‬ ‫ﻨﻘﻁﺔ ﻫﺎﻤﺔ ﻭﺍﺨﻴﺭﺓ، ﻋﻤﺭ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻤﺴﺘﻤﺭ ﺤﺘـﻰ ﻨﻬﺎﻴـﺔ ﺍﻻﺠـﺭﺍﺀ ﻭﻟـﻴﺱ ﻨﻬﺎﻴـﺔ‬ ‫ﺍﻟﺘﺭﻜﻴﺏ ﺍﻟﺫﻱ ﻋﺭﻓﺕ ﻓﻴﻪ، ﻓﺎﻟﻤﺘﻐﻴﺭ ‪ x‬ﺍﻟﺘﺎﻟﻲ ﺴﻴﺤﺘﻔﻅ ﺒﻘﻴﻤﺘﻪ ﺤﺘﻰ ﻭﺍﻥ ﺨﺭﺠﺕ ﻤﻥ ﺘﺭﻜﻴـﺏ ﺍﻟﺤﻠﻘـﺔ‬ ‫‪For‬‬ ‫2‪ counter‬ﺍﻟﺫﻱ ﻋﺭﻑ ﻓﻴﻬﺎ:‬ ‫‪Dim counter As Integer‬‬ ‫‪Dim counter2 As Integer‬‬ ‫3 ‪For counter = 1 To‬‬ ‫3 ‪For counter2 = 1 To‬‬ ‫ﺳﻴﺴﺘ ﻤﺮ ﰲ اﻻﺣﺘﻔ ﺎظ ﺑﻘ ﻴﻤﺘ ﻪ ' ‪Dim x As Integer‬‬ ‫1 + ‪x = x‬‬ ‫)‪ArabicConsole.WriteLine(x‬‬ ‫‪Next‬‬ ‫‪Next‬‬ ‫ﻤﺨﺭﺠﺎﺕ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ ﺴﺘﻜﻭﻥ:‬ ‫1‬ ‫2‬ ‫3‬ ‫4‬ ‫5‬ ‫6‬ ‫7‬ ‫8‬ ‫9‬
  • 65.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫93‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺤﻠﻴﺔ ﺍﻟﺴﺘﺎﺘﻴﻜﻴﺔ:‬ ‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺤﻠﻴﺔ ﺍﻟﺴﺘﺎﺘﻴﻜﻴﺔ ‪ Static Local Variables‬ﻫﻲ ﻨﻔﺱ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺤﻠﻴﺔ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴـﺔ، ﻟـﺫﻟﻙ‬ ‫ﻜل ﻤﺎ ﻗﻠﺘﻪ ﻓﻲ ﺍﻟﻔﻘﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ ﻴﻨﻁﺒﻕ ﻫﻨﺎ ﺩﻭﻥ ﺍﻱ ﺍﺨﺘﻼﻑ، ﺒﺎﺴـﺘﺜﻨﺎﺀ ﺍﻥ ﻋﻤﺭﻫـﺎ ﺍﻻﻓﺘﺭﺍﻀـﻲ ﺍﺒـﺩﻱ )ﺍﻱ‬ ‫ﻴﺴﺘﻤﺭ ﺍﻟﻤﺘﻐﻴﺭ ﺍﻻﺴﺘﻜﺎﺘﻴﻜﻲ ﻤﺤﺘﻔﻅﺎ ﺒﻘﻴﻤﺘﻪ ﺤﺘﻰ ﻨﻬﺎﻴﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻭ ﻤـﻭﺕ ﺍﻟﻜـﺎﺌﻥ ﺍﻟﺘـﺎﺒﻊ ﻟـﻪ(، ﻜﻤـﺎ ﺍﻨـﻙ‬ ‫ﹰ‬ ‫ﺴﺘﺴﺘﺨﺩﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Static‬ﻋﻭﻀﺎ ﻋﻥ ‪ Dim‬ﻟﻠﺘﺼﺭﻴﺢ ﻋﻥ ﻤﺘﻐﻴﺭ ﺴﺘﺎﺘﻴﻜﻲ:‬ ‫‪Static staticVariable As Integer‬‬ ‫ﻻ ﺘﺤﺎﻭل ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﺴﺘﺎﺘﻴﻜﻴﺔ ﻜﺜﻴﺭﺍ، ﻓﻬﻲ ﺍﺒﻁﺄ ﻤـﻥ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴـﺔ، ﻜﻤـﺎ ﺍﻨﻬـﺎ‬ ‫ﺘﺤﺠﺯ ﻤﺴﺎﺤﺔ ﻓﻲ ﺍﻟﺫﺍﻜﺭﺓ ﻁﻭﺍل ﻓﺘﺭﺓ ﻋﻤل ﺍﻟﺒﺭﻨﺎﻤﺞ ﺩﻭﻥ ﺃﻥ ﻴﻜﻭﻥ ﻫﻨﺎﻙ ﺤﺎﺠﺔ ﻤﺎﺴﺔ ﺇﻟﻴﻬـﺎ. ﻗـﺩ ﺘﺴـﺘﺨﺩﻡ‬ ‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﺴﺘﺎﺘﻴﻜﻴﺔ ﻤﺜﻼ ﻟﻼﺤﺘﻔﺎﻅ ﺒﻘﻴﻤﺔ ﻋﺩﺍﺩ ﺍﻭ ﺘﻨﻔﻴﺫ ﺍﺠﺭﺍﺀ ﻤﺭﺓ ﻭﺍﺤﺩﺓ:‬ ‫)( ‪Sub Counter‬‬ ‫‪Static counter As Integer‬‬ ‫1 + ‪counter = counter‬‬ ‫…‬ ‫…‬ ‫‪End Sub‬‬ ‫)( ‪Sub PrintData‬‬ ‫‪Static isPrinting As Boolean‬‬ ‫‪If isPrinting Then‬‬ ‫‪Exit Sub‬‬ ‫‪Else‬‬ ‫‪isPrinting = True‬‬ ‫‪End If‬‬ ‫…‬ ‫…‬ ‫‪End Sub‬‬ ‫ﺍﺨﻴﺭﺍ، ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Static‬ﻻ ﺘﻁﺒﻕ ﺍﻻ ﻋﻠﻰ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺤﻠﻴﺔ، ﻓﻼ ﺘﺤﺎﻭل ﺍﺴـﺘﺨﺩﺍﻤﻬﺎ ﻤـﻊ‬ ‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻋﻠﻰ ﻤﺴﺘﻭﻯ ﺍﻟﻭﺤﺩﺓ ﺍﻭ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﻤﺔ ﻓﻬﻲ ﺴﺘﺎﺘﻴﻜﻴﺔ ﺒﻁﺒﻴﻌﺘﻬﺎ.‬ ‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻋﻠﻰ ﻤﺴﺘﻭﻯ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﻤﺔ:‬ ‫ﻗﺩ ﺘﻭﺩ ﻤﻥ ﺍﻻﺠﺭﺍﺀﺍﺕ ﺍﻟﻤﺨﺘﻠﻔﺔ ﺍﻟﺘﺎﺒﻌﺔ ﻟﻭﺤﺩﺓ ﺒﺭﻤﺠﻴﺔ ﻤﻌﻴﻨـﺔ ﻤﺸـﺎﺭﻜﺔ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﻓﻴﻤـﺎ ﺒﻴﻨﻬـﺎ، ﻴﻤﻜﻨـﻙ‬ ‫‪ Visual Basic .NET‬ﻤﻥ ﻋﻤل ﺫﻟﻙ ﻋﻥ ﻁﺭﻴﻕ ﺘﺼﺭﻴﺢ ﻤﺘﻐﻴﺭﺍﺕ ﻋﻠـﻰ ﻤﺴـﺘﻭﻯ ﺍﻟﻭﺤـﺩﺓ ‪Module‬‬ ‫‪ ،Level Variables‬ﻭﺒﻬﺫﺍ ﻴﻜﻭﻥ ﻤﺩﻯ ﻫﺫﻩ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺸﺎﻤﻼ ﻟﺠﻤﻴﻊ ﺍﺠﺭﺍﺀﺍﺕ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴـﺔ. ﺍﺴـﺘﺨﺩﻡ‬ ‫ﹰ‬ ‫ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Private‬ﺍﻭ ‪ Dim‬ﻟﺘﻌﺭﻴﻑ ﻤﺘﻐﻴﺭ ﻋﻠﻰ ﻤﺴﺘﻭﻯ ﺍﻟﻭﺤﺩﺓ ﺸﺭﻴﻁﺔ ﺍﻥ ﻴـﺘﻡ ﺍﻟﺘﺼـﺭﻴﺢ ﻋـﻥ‬ ‫ﺍﻟﻤﺘﻐﻴﺭ ﺨﺎﺭﺝ ﺍﻻﺠﺭﺍﺀﺍﺕ:‬
  • 66.
    ‫04‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫1‪Module Module‬‬ ‫ﻣﺘﻐﲑات ﻋﻠﻰ ﻣ ﺴﺘﻮى اﻟﻮﺣﺪ ة '‬ ‫‪Dim x As Integer‬‬ ‫‪Private y As Integer‬‬ ‫)(‪Sub Main‬‬ ‫05 = ‪x‬‬ ‫…‬ ‫‪End Sub‬‬ ‫)( ‪Sub Test‬‬ ‫01 = ‪y‬‬ ‫…‬ ‫‪End Sub‬‬ ‫‪End Module‬‬ ‫ﺍﻤﺎ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﻤﺔ ‪ Global Variables‬ﻓﻤﺩﺍﻫﺎ ﻴﺸﻤل ﺠﻤﻴﻊ ﺸﻭﺍﺭﻉ ﻭﺍﻭﺩﻴﺔ ﻭﻤﻠﻔﺎﺕ ﺍﻟﺒﺭﻨـﺎﻤﺞ،‬ ‫ﻭﻟﻴﺴﺕ ﻤﺤﺼﻭﺭﺓ ﻟﻭﺤﺩﺓ ﺒﺭﻤﺠﻴﺔ ﻤﻌﻴﻨﺔ. ﺍﺴﺘﺨﺩﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Public‬ﻟﺘﻌﺭﻴﻑ ﻤﺘﻐﻴﺭ ﻋﺎﻡ:‬ ‫ﻣﺘﻐﲑ ﻋﺎ م '‬ ‫1‪Module Module‬‬ ‫‪Public x As Integer‬‬ ‫)(‪Sub Main‬‬ ‫5 = ‪x‬‬ ‫…‬ ‫‪End Sub‬‬ ‫‪End Module‬‬ ‫ﳝﻜﻦ ا ﻟﻮﺻﻮل اﱃ ا ﳌﺘﻐ ﲑ '‬ ‫وﺣﺪة ﺑﺮﳎ ﻴﺔ اﺧ ﺮ ى '‬ ‫2‪Module Module‬‬ ‫)(‪Sub Test‬‬ ‫1 = ‪x‬‬ ‫…‬ ‫‪End Sub‬‬ ‫‪End Module‬‬ ‫ﻣﻼﺣﻈﺔ‬ ‫ﻳﻤﻜﻨﻚ اﻳ ﻀﺎ اﺳﺘﺨﺪام اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ Friend‬ﻟﺘﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ ﻋﺎم، وﻟﻜﻨﻬﺎ‬ ‫ﺗﺨﺘ ﻠﻒ ﻋﻦ اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ Public‬ﻓﻲ ﻗﺎﺑﻠﻴﺔ اﻟﻮ ﺻﻮل اﻟﻰ اﻟﻤﺘﻐﻴﺮ ﻣﻦ‬ ‫ﻣﺸﺮوع ﺧﺎرﺟﻲ. ﺣﻴﺚ ﺗﺤ ﺼﺮ ‪ Friend‬ﻣﺪى اﻟﻤﺘﻐﻴﺮ ﻋﻠﻰ اﻟﻤﺸﺮوع اﻟﺤﺎﻟﻲ‬ ‫ﻓﻘﻂ.‬ ‫ﻭﻜﻤﻌﻴﺎﺭ ﻟﻠﺘﺴﻤﻴﺔ، ﺘﻘﺘﺭﺡ ﻋﻠﻴﻙ ﻤﺴـﺘﻨﺩﺍﺕ ‪ .NET‬ﺍﺴـﺘﺨﺩﺍﻡ ﺍﺴـﻠﻭﺏ ‪ PascalCase‬ﻋﻨـﺩ ﺘﺴـﻤﻴﺔ‬ ‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﻤﺔ ﻭﺍﻻﺴﻠﻭﺏ ‪ smallCase‬ﻟﻠﻤﺘﻐﻴﺭﺍﺕ ﻋﻠﻰ ﻤﺴﺘﻭﻯ ﺍﻟﻭﺤﺩﺓ:‬ ‫ﻣﺘﻐﲑات ﻋ ﺎﻣ ﺔ '‬ ‫‪Public ProgrammerName As String‬‬ ‫‪Friend ClientAge As Integer‬‬ ‫ﻣﺘﻐﲑات ﻋ ﻠﻰ ﻣﺴ ﺘﻮى ا ﻟﻮﺣﺪ ة '‬ ‫‪Dim programmerName As String‬‬ ‫‪Private clientAge As Integer‬‬
  • 67.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫14‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺍﺨﻴﺭﺍ، ﻋﻤﺭ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻋﻠﻰ ﻤﺴﺘﻭﻯ ﺍﻟﻭﺤﺩﺓ ﺍﻭ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﻤﺔ ﻤﺴﺘﻤﺭ ﺤﺘـﻰ ﻨﻬﺎﻴـﺔ ﺍﻟﺒﺭﻨـﺎﻤﺞ ﺍﻭ‬ ‫ﺍﻟﻜﺎﺌﻥ ﺍﻟﺘﺎﺒﻊ ﺍﻟﺫﻱ ﺼﺭﺤﺕ ﻓﻴﻪ.‬ ‫اﻧﻮاع اﻟﺒﻴﺎﻧﺎت‬ ‫ﻴﺒﺩﻭ ﺍﻥ ﺍﻟﻭﻗﺕ ﻗﺩ ﺤﺎﻥ ﻷﺨﺫ ﺠﻭﻟﺔ ﺘﻌﺭﻴﻔﻴﺔ ﺤﻭل ﺍﻨﻭﺍﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﺨﺘﻠﻔـﺔ ﺍﻟﺘـﻲ ﺘﺴـﺘﻁﻴﻊ ﺍﺴـﺘﺨﺩﺍﻤﻬﺎ ﻓـﻲ‬ ‫ﺒﺭﺍﻤﺠﻙ، ﻭﻟﻜﻥ ﺩﻋﻨﻲ ﺍﻭﻀﺢ ﻟﻙ ﻨﻅﺭﺘﻲ ﺍﻟﺸﺨﺼﻴﺔ ﺤﻭل ﻫﺫﻩ ﺍﻟﻔﻘﺭﺓ:‬ ‫ﺍﻨﻭﺍﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ )ﻜـ ‪.... Date ،Long ،Integer ،String‬ﺍﻟﺦ( ﻻ ﺘﺘﺒﻊ –ﺘﻘﻨﻴـﺎ - ﻟﻠﻐـﺔ ﺍﻟﺒﺭﻤﺠـﺔ‬ ‫‪ ،Visual Basic .NET‬ﻓﻬﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﻓﺌﺎﺕ ‪ Classes‬ﻭﺘﺭﻜﻴﺒﺎﺕ ‪ Structures‬ﻋﺭﻓـﺕ ﻓـﻲ ﻤﻜﺘﺒـﺔ‬ ‫ﻓﺌﺎﺕ ‪) BCL‬ﺍﻟﺘﺎﺒﻌﺔ ﻻﻁﺎﺭ ﻋﻤل ‪ .NET Framework‬ﻭﺍﻟﺘﻲ ﺘﺤـﺩﺜﺕ ﻋﻨﻬـﺎ ﻓـﻲ ﺍﻟﻔﺼـل ﺍﻟﺴـﺎﺒﻕ(،‬ ‫ﻭﺒﻌﺒﺎﺭﺓ ﺃﺨﺭﻯ: ﻜل ﺸﺊ ﺘﺭﺍﻩ ﻓﻲ ﺸﻴﻔﺭﺍﺘﻙ ﻋﺒـﺎﺭﺓ ﻋـﻥ ﻜـﺎﺌﻥ ‪ ،Object‬ﻓـﺎﻥ ﻜﻨـﺕ ﻤـﻥ ﺍﻟﻤﺒـﺭﻤﺠﻴﻥ‬ ‫ﺍﻟﻤﺨﻀﺭﻤﻴﻥ ﻋﻠﻴﻙ ﺍﻥ ﺘﻌﻠﻡ ﻋﻠﻡ ﺍﻟﻴﻘﻴﻥ ﺍﻥ ﺠﻤﻴﻊ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﺘﻲ ﺘﺼﺭﺡ ﻋﻨﻬﺎ ﻭﺘﺴـﺘﺨﺩﻤﻬﺎ ﻓـﻲ ﺒﺭﺍﻤﺠـﻙ،‬ ‫ﻤﺎﻫﻲ ﺍﻻ ﻜﺎﺌﻨﺎﺕ ﻤﻨﺸﺄﺓ ﻤﻥ ﻓﺌﺎﺕ ﺍﻭ ﺘﺭﻜﻴﺒﺎﺕ ﻤﻌﺭﻓﺔ ﻤﺴﺒﻘﺎ. ﻓﺤﺘﻰ ﺍﺒﺴﻁ ﺍﻨـﻭﺍﻉ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﻤﺜـل ‪،Byte‬‬ ‫ﹰ‬ ‫ﻓﻬﻭ ﻋﺒﺎﺭﺓ ﻋﻥ ﻜﺎﺌﻥ ﻟﻪ ﻁﺭﻕ ﻭﺨﺼﺎﺌﺹ ﺘﺎﺒﻌﻪ ﻟﻪ. ﻭﺒﻤﺎ ﺍﻨﻨﺎ ﻤﺎ ﺯﻟﻨﺎ ﻓﻲ ﺒﺩﺍﻴﺔ ﺘﻌﻠﻡ ﺍﺴﺎﺴﻴﺎﺕ ﻟﻐـﺔ ﺍﻟﺒﺭﻤﺠـﺔ‬ ‫‪ ،Visual Basic .NET‬ﻓﻼ ﺍﻋﺘﻘﺩ ﺍﻨﻪ ﻤﻥ ﺍﻟﻤﻨﺎﺴﺏ –ﺤﺎﻟﻴﺎ ﻋﻠﻰ ﺍﻷﻗل - ﺍﻟﺘﺤﺩﺙ ﻋﻥ ﻫـﺫﻩ ﺍﻻﻨـﻭﺍﻉ ﻗﺒـل‬ ‫ﺍﺴﺘﻴﻌﺎﺏ ﺍﻟﻜﺎﺌﻨﺎﺕ ﻭﺍﻟﻔﺌﺎﺕ )ﻭﻫﻭ ﻤﻭﻀﻭﻉ ﺍﻟﻔﺼل ﺍﻟﺜﺎﻟﺙ ﺍﻟﻔﺌﺎﺕ ﻭﺍﻟﻜﺎﺌﻨﺎﺕ(، ﻟـﺫﻟﻙ ﻜـﺎﻥ ﻗـﺭﺍﺭﻱ ﺍﻟﻨﻬـﺎﺌﻲ‬ ‫ﻫﻭ ﺘﺄﺠﻴل ﺘﻔﺼﻴل ﻫﺫﻩ ﺍﻻﻨﻭﺍﻉ ﺍﻟﻰ ﺍﻟﻔﺼل ﺍﻟﺴﺎﺩﺱ ﺍﻟﻔﺌﺎﺕ ﺍﻷﺴﺎﺴﻴﺔ. ﻭﺇﻟﻲ ﺍﻥ ﻨﻠﺘﻘﻲ ﻫﻨـﺎﻙ، ﻴﻌـﺭﺽ ﻟـﻙ‬ ‫ﺍﻟﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ﻤﻠﺨﺹ ﺴﺭﻴﻊ ﻻﻨﻭﺍﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻻﻭﻟﻴﺔ ‪ Primitive Data Types‬ﺍﻟﺘـﻲ ﻴـﺩﻋﻤﻬﺎ ‪Visual‬‬ ‫‪:Basic .NET‬‬ ‫ﺍﻟﻨﻭﻉ‬ ‫‪Boolean‬‬ ‫ﺍﻟﺤﺠ ﻡ‬ ‫ﻤﺠﺎل ﺍﻟﻘﻴﻤﺔ‬ ‫2 ﺒﺎﻴﺕ‬ ‫‪) True‬ﺼﺢ( ﺍﻭ ‪) False‬ﺨﻁﺄ(.‬ ‫‪Byte‬‬ ‫1 ﺒﺎﻴﺕ‬ ‫ﻋﺩﺩ ﺼﺤﻴﺢ ﻤﻥ 0 ﺍﻟﻰ 552 .‬ ‫‪Char‬‬ ‫2 ﺒﺎﻴﺕ‬ ‫ﺤﺭﻑ ﻭﺍﺤﺩ ﻤﻥ ﻨﻭﻉ ‪.UNICODE‬‬ ‫‪Date‬‬ ‫8 ﺒﺎﻴﺕ‬ ‫‪Decimal‬‬ ‫61 ﺒﺎﻴﺕ‬ ‫ﻭﻗﺕ ﻤﻥ ﺍﻟﺴﺎﻋﺔ 00:00:0 ﺍﻟﻰ ﺍﻟﺴﺎﻋﺔ 95:95:11، ﻜﻤﺎ‬ ‫ﻴﺸﻤل ﺘﺎﺭﻴﺦ ﻤﻥ ﻴﻭﻡ 1 ﻴﻨﺎﻴﺭ ﻟﻌﺎﻡ 1000 ﺍﻟﻰ 13 ﺩﻴﺴ ﻤﺒﺭ‬ ‫ﻟﻌﺎﻡ 9999 .‬ ‫ﻋﺩﺩ ﺼﺤﻴﺢ ﻤﻥ 0 ﺍﻟﻰ‬ ‫±533,059,345,395,733,462,415,261,822,97‬ ‫ﺍﻭ ﻋﺸﺭﻱ ﻤﻥ 0 ﺍﻟﻰ‬ ‫±5330593453957334624152618229.7‬
  • 68.
    ‫24‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺍﻟﻨﻭﻉ‬ ‫‪Double‬‬ ‫ﺍﻟﺤﺠ ﻡ‬ ‫ﻤﺠﺎل ﺍﻟﻘﻴﻤﺔ‬ ‫8 ﺒﺎﻴﺕ‬ ‫ﻋﺩﺩ ﻋﺸﺭﻱ ﻤﻥ 803+‪ 1.79769313486231570E‬ﺍﻟﻰ‬ ‫‪Integer‬‬ ‫4 ﺒﺎﻴﺕ‬ ‫‪Long‬‬ ‫8 ﺒﺎﻴﺕ‬ ‫‪Object‬‬ ‫4 ﺒﺎﻴﺕ‬ ‫ﺠﻤﻴﻊ ﺍﻟﻘﻴﻡ ﻭﺍﻻﻨﻭﺍﻉ ﻴﻤﻜﻥ ﺤﻔﻅﻬﺎ ﻫﻨﺎ .‬ ‫‪Short‬‬ ‫2 ﺒﺎﻴﺕ‬ ‫ﻋﺩﺩ ﺼﺤﻴﺢ ﻤﻥ – 867,23 ﺍﻟﻰ 767,23.‬ ‫423-‪ 4.94065645841246544E‬ﺒﺎﻟﻨﺴﺒﺔ ﻟﻼﻋﺩﺍﺩ ﺍﻟﺴﺎﻟﺒﺔ.‬ ‫ﻭﻤﻥ‬ ‫423-‪ 4.94065645841246544E‬ﺍﻟﻰ‬ ‫803+‪ 1.79769313486231570E‬ﺒﺎﻟﻨﺴﺒﺔ ﻟﻼﻋﺩﺍﺩ‬ ‫ﺍﻟﻤﻭﺠﺒﻪ .‬ ‫ﻋﺩﺩ ﺼﺤﻴﺢ ﻤﻥ – 846,384,741,2 ﺍﻟﻰ‬ ‫746,384,741,2.‬ ‫ﻋﺩﺩ ﺼﺤﻴﺢ ﻤﻥ - 808,577,458,630,273,322,9 ﺍﻟﻰ‬ ‫708,577,458,630,273,322,9.‬ ‫‪Single‬‬ ‫4 ﺒﺎﻴﺕ‬ ‫‪String‬‬ ‫01 + )2 * ﻋﺩﺩ‬ ‫ﻋﺩﺩ ﻋﺸﺭﻱ ﻤﻥ 83+‪ 3.4028235E‬ﺍﻟﻰ 54-‪1.401298E‬‬ ‫ﺒﺎﻟﻨﺴﺒﺔ ﻟﻼﻋﺩﺍﺩ ﺍﻟﺴﺎﻟﺒﺔ. ﻭﻤﻥ 54-‪ 1.401298E‬ﺍﻟﻰ‬ ‫83+‪ 3.4028235E‬ﺒﺎﻟﻨﺴﺒﺔ ﻟﻼﻋﺩﺍﺩ ﺍﻟﻤﻭﺠﺒﻪ .‬ ‫ﻤﻥ 0 ﺍﻟﻰ 2 ﻤﻠﻴﺎﺭ ﺤﺭﻑ ﻤﻥ ﻨﻭﻉ ‪.UNICODE‬‬ ‫ﺍﻟﺤﺭﻭﻑ( ﺒﺎﻴﺕ‬ ‫ﻋﻨﺩﻤﺎ ﺘﻤﻌﻥ ﺍﻟﻨﻅﺭ ﻓﻲ ﺍﻟﺠﺩﻭل ﺍﻟﺴﺎﺒﻕ، ﺴﺘﻼﺤﻅ ﻭﺠﻭﺩ ﻨﻭﻋﻴﻥ ﻤﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺤﺭ ﻓﻴـﺔ ﻫﻤـﺎ ‪ Char‬ﻭ‬ ‫‪ .String‬ﺒﺎﻟﻨﺴﺒﺔ ﻟﻠﻨﻭﻉ ﺍﻻﻭل ﻓﻬﻭ ﻴﻤﺜل ﺤﺭﻑ ﻭﺍﺤﺩ ﻓﻘﻁ ﻤﻥ ﺤﺭﻭﻑ ‪ ،Unicode‬ﻟﺫﻟﻙ ﻓـﺎﻟﻤﺘﻐﻴﺭﺍﺕ ﻤـﻥ‬ ‫ﺍﻟﻨﻭﻉ ‪ Char‬ﻻﻴﻤﻜﻥ ﺍﻥ ﺘﺤﻤل ﻗﻴﻤﺔ ﺤﺭﻓﻴﻪ ﺘﺯﻴﺩ ﻋﻥ ﺤﺭﻑ ﻭﺍﺤﺩ، ﻜﻤﺎ ﻴﺸﺭﻁ ﺍﺴﺘﺨﺩﺍﻡ ﺤـﺭﻑ ﺍﻟـﺫﻴل "‪"c‬‬ ‫ﺤﺘﻰ ﺘﻤﻴﺯ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺤﺭﻓﻴﺔ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Char‬ﻋﻥ ﻗﻴﻤﺔ ﺴﻠﺴﻠﺔ ﺍﻟﺤﺭﻭﻑ ﻤﻥ ﺍﻟﻨﻭﻉ ‪:String‬‬ ‫‪Dim A As Char‬‬ ‫رﺳﺎﻟﺔ ﺧﻄ ﺄ هﻨ ﺎ '‬ ‫‪"c‬ت" = ‪A‬‬ ‫‪"c‬ﺗﺮآ ﻲ" = ‪A‬‬ ‫ﻗﺩ ﺘﺴﺘﻐﺭﺏ ﻤﺩﻯ ﺍﻟﺠﺩﻭﻯ ﻤﻥ ﺍﻻﻋﺘﻤﺎﺩ ﻋﻠﻰ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻤﻥ ﻨﻭﻉ ‪ Char‬ﺒـﺩﻻ ﻤـﻥ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﻤـﻥ‬ ‫ﻨﻭﻉ ‪ String‬ﺭﻏﻡ ﺍﻤﻜﺎﻨﻴﺎﺘﻬﺎ ﺍﻟﻤﺤﺩﻭﺩﺓ، ﺍﻟﺴﺒﺏ ﺒﺒﺴﺎﻁﺔ ﺍﻟﺴـﺭﻋﺔ ﻓـﻲ ﺍﻟﺘﻨﻔﻴـﺫ ﻭﺍﻻﻗﺘﺼـﺎﺩ ﻓـﻲ ﺍﺴـﺘﻬﻼﻙ‬ ‫ﻤﺼﺎﺩﺭ ﺍﻟﻨﻅﺎﻡ. ﺤﻴﺙ ﺃﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻤﻥ ﻨﻭﻉ ‪ Char‬ﻫﻲ ﻤﺘﻐﻴﺭﺍﺕ ﻤﻥ ﺍﻟﻨـﻭﻉ ﺫﺍﺕ ﺍﻟﻘﻴﻤـﺔ ‪Value Type‬‬ ‫‪ Variables‬ﺒﻴﻨﻤـﺎ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﻤـﻥ ﺍﻟﻨـﻭﻉ ‪ String‬ﻫـﻲ ﻤﺘﻐﻴـﺭﺍﺕ ﻤﺭﺠﻌﻴـﺔ ‪Reference Type‬‬ ‫‪ .Variables‬ﺍﻟﻔﺭﻭﻕ ﺒﻴﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ ﻫﻭ ﻤﻭﻀﻭﻉ ﺍﻟﻔﻘﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ.‬
  • 69.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫34‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ:‬ ‫ﺘﻭﺠﺩ ﻤﺴﺎﺌل ﺘﻘﻨﻴﺔ ﺒﺤﺘﺔ ﺘﻌﺘﺒﺭ ﻓﻲ ﻏﺎﻴﺔ ﺍﻻﻫﻤﻴﺔ ﺘﺘﻌﻠﻕ ﺒﺎﻟﻤﺘﻐﻴﺭﺍﺕ، ﺤﻴﺙ ﺍﻨﻲ ﺫﻜﺭﺕ -ﻓﻲ ﺒﺩﺍﻴﺔ ﻫـﺫﺍ ﺍﻟﻘﺴـﻡ‬ ‫ﻤﻥ ﺍﻟﻔﺼل - ﺍﻥ ﺍﻟﺒﻨﻴﺔ ﺍﻟﺘﺤﺘﻴﺔ ﻟﻠﻤﺘﻐﻴﺭﺍﺕ ﻗﺩ ﺘﻐﻴﺭﺕ ﺘﻐﻴﺭﺍ ﺠﺫﺭﻴﺎ ﻋﻤﺎ ﻜﺎﻨـﺕ ﻋﻠﻴـﻪ ﻓـﻲ ﻟﻐـﺎﺕ ﺍﻟﺒﺭﻤﺠـﺔ‬ ‫ﹰ‬ ‫ﹰ‬ ‫ﺍﻟﺴﺎﺒﻘﺔ، ﺍﺫ ﺍﻥ ﺍﻟﻘﻀﻴﺔ ﺍﺒﻌﺩ ﻤﻥ ﺃﻥ ﺘﻜﻭﻥ ﻤﺠﺭﺩ ﻤﻨﻁﻘﺔ ﻤﺤﺠﻭﺯﺓ ﻓـﻲ ﺍﻟـﺫﺍﻜﺭﺓ ﺘﺤﻔـﻅ ﺒﻬـﺎ ﻗﻴﻤـﺔ ﻟﺘﻤﺜـل‬ ‫ﺍﻟﻤﺘﻐﻴﺭ، ﻓﻜل ﺸﻲﺀ ﺘﺭﺍﻩ ﻓﻲ ‪ Visual Basic .NET‬ﻫﻭ ﻜﺎﺌﻥ ‪ Object‬ﻜﻤﺎ ﺍﺘﻔﻘﻨﺎ ﺴـﺎﺒﻘﺎ. ﻭﻟﻜـﻥ ﻋﻠﻴـﻙ‬ ‫ﻤﻌﺭﻓﺔ ﺍﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ –ﺍﻭ ﺍﻨﻭﺍﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺼﻔﺔ ﻋﺎﻤﺔ - ﻓﻲ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠـﺔ ‪ Visual Basic .NET‬ﺘﻨﻘﺴـﻡ‬ ‫ﺍﻟﻰ ﻗﺴﻤﻴﻥ ﺭﺌﻴﺴﻴﻥ ﻤﻬﻤﺎ ﺍﺨﺘﻠﻔﺕ ﺍﻨﻭﺍﻋﻬﺎ ﻫﻤﺎ: ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠ ﻌﻴـﺔ ‪Reference Type Variables‬‬ ‫ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ ‪.Value Type Variables‬‬ ‫ﺴﺄﺒﺩﺍ ﻤﻌﻙ ﺒﺎﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ ‪ ،Value Type Variables‬ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﻤﺸـﺘﻕ‬ ‫ﻭﺭﺍﺜﻴﺎ ﻤﻥ ﺍﻟﻔﺌﺔ ‪) System.ValueType‬ﺍﻟﻭﺭﺍﺜﺔ ﻭﺍﻻﺸﺘﻘﺎﻕ ﺍﻟﻭﺭﺍﺜﻲ ﻤﻭﻀﻭﻉ ﺍﻟﻔﺼل ﺍﻟﺭﺍﺒـﻊ ﺍﻟﻭﺭﺍﺜـﺔ(.‬ ‫ﺘﻘﻨﻴﺎ، ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺸﺒﻴﻪ ﺒﻔﻜﺭﺓ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﻟﻐـﺎﺕ ﺍﻟﺒﺭﻤﺠـﺔ ﺍﻟﺴـﺎﺒﻘﺔ، ﺤﻴـﺙ ﺍﻥ‬ ‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺘﺤﻔﻅ ﻗﻴﻤﻬﺎ ﻓﻲ ﻗﺴﻡ ﻤﻥ ﺫﺍﻜﺭﺓ ﺍﻟﺒﺭﻨﺎﻤﺞ ) ﻗﺩ ﺘﻜﻭﻥ ‪ Stack‬ﻓﻲ ﻤﻌﻅﻡ ﺍﻻﺤﻭﺍل(، ﻭﺴـﺘﻤﺤﻰ ﻤـﻥ‬ ‫ﺍﻟﺫﺍﻜﺭﺓ ﻤﺒﺎﺸﺭﺓ ﺒﻌﺩ ﻨﻬﺎﻴﺔ ﻋﻤﺭ ﺍﻟﻤﺘﻐﻴـﺭ. ﺠﻤﻴـﻊ ﺍﻟﺒﻴﺎﻨـﺎﺕ ﺍﻟﻌﺩﺩﻴـﺔ ‪ ،Numbers‬ﻭﺍﻟﺒﻴﺎﻨـﺎﺕ ﻤـﻥ ﺍﻟﻨـﻭﻉ‬ ‫‪ ،Char ،Boolean‬ﻭ ‪ ،Date‬ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﻌﺭﻓﺔ ﻤﻥ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ‪ Structures‬ﺍﻭ ‪ Enums‬ﻫﻲ ﺒﻴﺎﻨـﺎﺕ‬ ‫ﻤﻥ ﺍﻟﻨﻭﻉ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ ‪.Value Type‬‬ ‫ﺍﻤﺎ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ ‪ ،Reference Type‬ﻓﻴﻭﺠﺩ ﺍﻟﻜﺜﻴﺭ ﻻﺨﺒﺭﻙ ﺒﻪ ﻋﻨﻬﺎ ﻻﺤﻘﺎ، ﻭﻟﻜﻥ ﻜـل ﻤـﺎ‬ ‫ﺍﺭﻴﺩ ﻤﻨﻙ ﺍﻥ ﺘﻌﻠﻤﻪ ﻋﻨﻬﺎ ﻓﻲ ﺍﻟﻭﻗﺕ ﺍﻟﺤﺎﻟﻲ ﻫﻭ ﺍﻥ ﻗﻴﻤﺔ ﺍﻟﻤﺘﻐﻴﺭ )ﻴﺴﻤﻰ ﻤﺅﺸﺭ ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ( ﻴـﺘﻡ ﺤﻔﻅـﻪ‬ ‫ﻜﻤﺎ ﺘﺤﻔﻅ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ، ﺒﻴﻨﻤﺎ ﺘﺤﻔﻅ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺤﻘﻴﻘﺔ ﻟﻠﻜﺎﺌﻥ ﻓﻲ ﻗﺴﻡ ﺨﺎﺹ ﻤـﻥ ﺫﺍﻜـﺭﺓ ﺍﻟﺒﺭﻨـﺎﻤﺞ‬ ‫ﻴﺴﻤﻰ ‪ ،Managed Heap‬ﻭﻓﻲ ﺍﻟﺤﻘﻴﻘﺔ ﻻ ﺘﺘﻡ ﻋﻤﻠﻴﺔ ﺍﺯﺍﻟﺔ ﻗﻴﻤﻬﺎ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ﻤﺒﺎﺸﺭﺓ ﺒﻌﺩ ﻨﻬﺎﻴﺔ ﻋﻤﺭﻫـﺎ‬ ‫ﺍﻻﻓﺘﺭﺍﻀﻲ، ﻓﻬﻲ ﺘﺘﻁﻠﺏ ﻋﻤﻠﻴﺔ ﺘﺴﻤﻰ ﺍﻓﺭﺍﻍ ﺍﻟﻤﺼﺎﺩﺭ ﻋﻥ ﻁﺭﻴـﻕ ﻤﺠﻤﻭﻋـﺔ ‪Garbage Collection‬‬ ‫ﻤﻘﺩﻤﺔ ﻤﻥ ﺍﻁﺎﺭ ﻋﻤل ‪ .NET‬ﻓﻠﻭ ﻜﺎﻥ ﻟﺩﻴﻨﺎ ﻫﺫﻴﻥ ﺍﻟﻤﺘﻐﻴﺭﻴﻥ:‬ ‫ﻣﺘﻐﲑ ﻣﺮﺟ ﻌ ﻲ '‬ ‫ﻣﺘﻐﲑ ذا ﻗﻴﻤ ﺔ '‬ ‫"ﺗﺮآﻲ اﻟﻌ ﺴﲑ ي" = ‪Dim Name As String‬‬ ‫99 = ‪Dim Age As Integer‬‬ ‫ﻴﻤﻜﻨﻨﺎ ﺘﺨﻴل ﻤﻭﺍﻗﻌﻬﻤﺎ ﺒﺎﻟﺫﺍﻜﺭﺓ ﻜﻤﺎ ﻓﻲ ﺍﻟﺸﻜل ﺍﻟﺘﺎﻟﻲ:‬ ‫ﺸﻜل 2 -3: ﺍﻤﺎﻜﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ ﻓﻲ ﺍﻟﺫﺍﻜﺭﺓ.‬
  • 70.
    ‫44‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫اﻧﻈﺮ اﻳﻀﺎ‬ ‫ﻟﻲ ﻋﻮدة اﺧﺮى ﺣﻮل اﻟﻤﺘﻐﻴﺮات ذات اﻟﻘﻴﻤﺔ ﻓﻲ اﻟﻔ ﺼﻞ اﻟﺴﺎدس اﻟﻔﺌﺎت‬ ‫اﻻﺳﺎﺳﻴﺔ ، ﺑﻴﻨﻤﺎ ﺳﻴﻜﻮن ﻟﻲ ﺣﺪﻳﺚ ﻣﻄﻮل ﻋﻦ اﻟﻤﺘﻐﻴﺮات اﻟﻤﺮﺟﻌﻴﺔ ﻓﻲ‬ ‫اﻟﻔ ﺼﻞ اﻟﺜﺎﻟﺚ اﻟﻔﺌﺎت واﻟﻜﺎﺋﻨﺎت .‬ ‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ ،String‬ﻭﺍﻟﻤﺼﻔﻭﻓﺎﺕ ‪ ،Arrays‬ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﻌﺭﻓﺔ ﻤﻥ ﺍﻟﻔﺌـﺎﺕ ‪Classes‬‬ ‫ﺠﻤﻴﻌﻬﺎ ﻤﺘﻐﻴﺭﺍﺕ ﻤﺭﺠﻌﻴﺔ ‪.Reference Type‬‬ ‫ﻤﻥ ﻤﻨﻁﻠﻕ ﺍﻟﺘﺴﻠﺴل ﺍﻟﺘﻌﻠﻴﻤﻲ ﺍﻟﺫﻱ ﺍﺘﺒﻌﻪ ﻓﻲ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ، ﻻ ﺍﺭﻴﺩ ﺍﻋﻁﺎﺌـﻙ ﺠﻤﻴـﻊ ﺍﻟﻔﺭﻭﻗـﺎﺕ ﺒـﻴﻥ‬ ‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ ﻫﻨﺎ، ﺤﻴﺙ ﺍﻨﻲ ﺍﻓﻀل ﺫﻜﺭﻫﺎ ﻓﻲ ﺍﻤـﺎﻜﻥ ﻤﺘ ﻔﺭﻗـﺔ ﻤـﻥ ﻫـﺫﺍ‬ ‫ﺍﻟﻜﺘﺎﺏ ﻟﻜﻲ ﺘﻨﺎﺴﺏ ﺍﻟﻔﻘﺭﺍﺕ ﺍﻟﺘﺎﺒﻌﺔ ﻟﻬﺎ، ﻭﻟﻜﻥ ﺩﻋﻨﻲ ﺍﺨﺒﺭﻙ ﻫﻨﺎ ﺒﺎﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤـﺔ ﺍﺴـﺭﻉ ﺒﻜﺜﻴـﺭ‬ ‫ﻤﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ، ﻜﻤﺎ ﺍﻨﻬﺎ ﺍﻗﺘﺼﺎﺩﻴﺔ ﺠﺩﺍ ﻓﻲ ﺍﺴﺘﻬﻼﻙ ﻤﺼﺎﺩﺭ ﺍﻟﻨﻅﺎﻡ، ﻟﺫﻟﻙ ﺤﺎﻭل ﺍﻻﻋﺘﻤـﺎﺩ ﻋﻠﻴﻬـﺎ‬ ‫ﻋﻭﻀﺎ ﻋﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ ﺍﻻ ﺍﻥ ﺩﻋﺘﻙ ﺍﻟﺤﺎﺠﺔ ﻟﻐﻴﺭ ﺫﻟﻙ.‬ ‫اﺳﻨﺎد اﻟﻘﻴ ﻢ‬ ‫ﻗﺩ ﺘﺴﺘﻐﺭﺏ ﻤﻥ ﺘﺨﺼﻴﺹ ﻓﻘﺭﺓ ﻜﺎﻤﻠﺔ ﻋﻥ ﻋﻤﻠﻴﺔ ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ ﺍﻟﻰ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ، ﺍﻻ ﺍﻨـﻙ ﺴﺘﻜﺘﺸـﻑ ﺍﻥ ﺍﻻﻤـﺭ‬ ‫ﺒﺤﺎﺠﺔ ﺍﻟﻰ ﺍﻟﺘﻁﺭﻕ ﻟﺒﻌﺽ ﺍﻟﺘﻔﺎﺼﻴل ﺍﻟﺩﻗﻴﻘﺔ ﺤﻭل ﻫﺫﻩ ﺍﻟﻤﺴﺄﻟﺔ.‬ ‫ﺒﺎﺩﺉ ﺫﻱ ﺒﺩﺀ، ﺍﻨﺕ ﺘﻌﻠﻡ ﻭﺍﻨﺎ ﺍﻋﻠﻡ ﺍﻨﻨﺎ ﻨﺴﺘﻁﻴﻊ ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ ﺍﻟﻰ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺒﺎﺴـﺘﺨﺩﺍﻡ ﻤﻌﺎﻤـل ﺍﺴـﻨﺎﺩ‬ ‫ﺍﻟﻘﻴﻡ "="، ﻴﻤﻜﻨﻙ ﺍﺴﻨﺎﺩ ﻗﻴﻤﺔ ﻟﻠﻤﺘﻐﻴﺭ ﺒﻌﺩ ﺍﻟﺘﺼﺭﻴﺢ ﻋﻨـﻪ ﻤﺒﺎﺸـﺭﺓ، ﺍﻭ ﺍﺜﻨـﺎﺀ ﻋﻤﻠﻴـﺔ ﺍﻟﺘﺼـﺭﻴﺢ ﺒﻜـل‬ ‫ﺍﻨﺴﻴﺎﺒﻴﺔ:‬ ‫اﺳﻨﺎ د ﻗﻴﻤ ﺔ ﳊﻈﺔ اﻟﺘﺼ ﺮﻳ ﺢ ' 01 = ‪Dim X As Integer‬‬ ‫‪Dim Y As Integer‬‬ ‫‪Dim Z As Long‬‬ ‫02 = ‪Y‬‬ ‫03 = ‪Z‬‬ ‫ﺍﻥ ﺍﺴﻨﺩﺕ ﻗﻴﻡ ﻟﻠﻤﺘﻐﻴﺭﺍﺕ ﺍﺜﻨﺎﺀ ﻋﻤﻠﻴﺔ ﺍﻟﺘﺼﺭﻴﺢ ﻻﻜﺜﺭ ﻤﻥ ﻤﺘﻐﻴﺭ ﻓﻲ ﺴﻁﺭ ﻭﺍﺤﺩ، ﻋﻠﻴﻙ ﺘﺤﺩﻴـﺩ ﻨـﻭﻉ‬ ‫ﺍﻟﻤﺘﻐﻴﺭ ﻟﻜل ﺘﺼﺭﻴﺢ ﻭﺍﻻ ﺴﺘﻅﻬﺭ ﺭﺴﺎﻟﺔ ﺨﻁﺎ:‬ ‫هﻨﺎ ﳑﻜ ﻦ '‬ ‫03 = ‪Dim X As Integer, Y As Integer = 20, Z As Long‬‬ ‫رﺳﺎﻟﺔ ﺧﻄ ﺄ '‬ ‫03 = ‪Dim X, Y As Integer = 20, Z As Long‬‬
  • 71.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫54‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻟﺴﺕ ﺒﺤﺎﺠﺔ ﻻﺨﺒﺎﺭﻙ ﺍﻨﻙ ﺍﻟﻤﺴﺅﻭل ﺍﻻﻭل ﻭﺍﻻﺨﻴﺭ ﻋﻥ ﻤﺠﺎل ﺍﻟﻘﻴﻡ ﺍﻟﺘﻲ ﺘﺴـﻨﺩﻫﺎ ﺍﻟـﻰ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ،‬ ‫ﻭﺍﻥ ﺍﻀﻔﺕ ﻗﻴﻤﺔ ﺨﺎﺭﺝ ﻨﻁﺎﻕ ﻤﺠﺎل ﺍﻟﻘﻴﻡ ﺍﻟﻤﺴﻤﻭﺡ ﺒﻪ ﻟﻨﻭﻉ ﻤﻌﻴﻥ ﻤﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ، ﺴـﺘﻅﻬﺭ ﺭﺴـﺎﻟﺔ ﺨﻁـﺄ‬ ‫ﻭﻗﺕ ﺍﻟﺘﻨﻔﻴﺫ:‬ ‫رﺳﺎﻟﺔ ﺧﻄ ﺄ '‬ ‫652 = ‪Dim X As Byte‬‬ ‫ﺍﻟﻤﺯﻴﺩ ﺍﻴﻀﺎ، ﻴﻭﻓﺭ ﻟﻙ ‪ Visual Basic .NET‬ﻤﻌﺎﻤﻼﺕ ﺍﻀﺎﻓﻴﺔ ﻻﺴﻨﺎﺩ ﺍﻟﻘـﻴﻡ ﺍﻟـﻰ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ‬ ‫ﺘﻌﺘﺒﺭ ﺍﺨﺘﺼﺎﺭ ﻟﻌﻤﻠﻴﺎﺕ ﺭﻴﺎﻀﻴﺔ ﺸﺎﺌﻌﺔ ﺘﻭﻀﺤﻬﺎ ﻟﻙ ﻫﺫﻩ ﺍﻟﺸﻴﻔﺭﺓ:‬ ‫5 + 5 = ‪Dim X As Integer‬‬ ‫1‬ ‫2‬ ‫3‬ ‫6‬ ‫2‬ ‫+‬ ‫‬‫*‬ ‫‬ ‫^‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫=‬ ‫=‬ ‫=‬ ‫=‬ ‫=‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫‪x‬‬ ‫'‬ ‫'‬ ‫'‬ ‫'‬ ‫'‬ ‫1‬ ‫2‬ ‫3‬ ‫6‬ ‫2‬ ‫=+‬ ‫=-‬ ‫=*‬ ‫=‬ ‫=^‬ ‫‪X‬‬ ‫‪X‬‬ ‫‪X‬‬ ‫‪X‬‬ ‫‪X‬‬ ‫ﻤﻊ ﺍﻟﻌﻠﻡ ﺍﻥ ﺍﻟﻤﻌﺎﻤﻼﺕ ﺍﻟﺴﺎﺒﻘﺔ ﻻ ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﺍﺜﻨﺎﺀ ﻋﻤﻠﻴﺔ ﺍﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺍﻟﻤﺘﻐﻴﺭ:‬ ‫ﻟﻦ ﻳﺴﻤﺢ ﻟ ﻚ ‪ Visual Basic .NET‬ﺑﻜﺘﺎﺑﺔ ا ﻟﺸﻴﻔﺮ ة '‬ ‫ﺑﺎﻟﺸﻜﻞ ا ﻟﺘﺎﱄ ﺣﱴ ﻟﻮ ﺗﻮﺳﻂ ﺑﻴﻞ ﺟﻴﺘ ﺲ '‬ ‫01 =+ ‪Dim X As Integer‬‬ ‫02 =^ ‪Dim Y As Long‬‬ ‫ﺩﻋﻨﻲ ﺍﻭﻀﺢ ﻟﻙ ﻗﻀﻴﺔ ﺘﻘﻨﻴﺔ ﺘﺘﻌﻠﻕ ﺒﺎﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ ﺤﻴﺙ ﺘﺒﻴﻥ ﻟﻨﺎ ﺍﺤـﺩ ﺍﻟﻔـﺭﻭﻕ ﺒـﻴﻥ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺫﺍﺕ‬ ‫ﺍﻟﻘﻴﻤﺔ ‪ Value Type‬ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ ‪ .Reference Type‬ﻋﻤﻠﻴﺔ ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ ﺒـﻴﻥ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺫﺍﺕ‬ ‫ﺍﻟﻘﻴﻤﺔ ﺘﻘﻭﻡ ﺒﻨﺴﺦ ﻓﻌﻠﻲ ﻟﻠﻤﺘﻐﻴﺭﺍﺕ ﻟﻴﺴﺘﻘل ﻜل ﻤﺘﻐﻴﺭ ﺒﻘﻴﻤﺘﻪ، ﺍﻤﺎ ﺍﺴﻨﺎﺩ ﺍﻟﻘـﻴﻡ ﺒـﻴﻥ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴـﺔ،‬ ‫ﻓﻬﻲ ﻻ ﺘﺅﺩﻱ ﺇﻟﻰ ﻨﺴﺦ ﻗﻴﻡ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ، ﺒل ﻜل ﻤﺎ ﺘﻘﻭﻡ ﺒﻪ ﻫﻭ ﻨﺴﺦ ﺍﻟﻤﺅﺸﺭﺍﺕ ﻟﺘﺸـﻴﺭ ﺍﻟـﻰ ﻨﻔـﺱ ﺍﻟﻜـﺎﺌﻥ‬ ‫ﺍﻟﺫﻱ ﻴﺤﻤل ﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻔﻌﻠﻴﺔ )ﻭﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ .(Managed Heap‬ﺍﻥ ﻟـﻡ ﺘﻔﻬـﻡ ﺸـﻴﺌﺎ ﻤﻤـﺎ‬ ‫ﺴﺒﻕ، ﺭﻜﺯ ﻓﻲ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ ﻭﺍﻟﻤﻭﻀﺤﺔ ) ﺒﺎﻟﺸﻜل 2 -4( ﻓﻲ ﺍﻟﺼﻔﺤﺔ ﺍﻟﺘﺎﻟﻴﺔ:‬ ‫ﻣﺘﻐﲑات ﻣ ﺮﺟﻌﻴ ﺔ '‬ ‫"ﺗﺮآﻲ اﻟﻌ ﺴﲑ ي" = ‪Dim Name As String‬‬ ‫‪Dim Name2 As String = Name‬‬ ‫ﻣﺘﻐﲑات ذ ات ﻗﻴ ﻤ ﺔ '‬ ‫99 = ‪Dim Age As Integer‬‬ ‫‪Dim Age2 As Integer = Age‬‬
  • 72.
    ‫64‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺸﻜل 2 -4: ﺘﻭﻀﻴﺢ ﺍﻟﻔﺭﻕ ﻓﻲ ﻋﻤﻠﻴﺔ ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ ﺒﻴﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ ﻭﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ.‬ ‫ﻜﻤﺎ ﺘﺭﻯ ﻓﻲ )ﺍﻟﺸﻜل 2 -4(، ﺭﻏﻡ ﺍﻨﻲ ﻋﺭﻓﺕ ﻤﺘﻐﻴﺭﻴﻥ ﻤﺨﺘﻠﻔـﻴﻥ )‪ Name‬ﻭ 2‪ (Name‬ﺍﻻ ﺍﻨﻬﻤـﺎ‬ ‫ﻻ ﻴﺯﺍﻻﻥ ﻴﺸﻴﺭﺍﻥ ﺍﻟﻰ ﻨﻔﺱ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻔﻌﻠﻴﺔ ﻟﻠﻤﺘﻐﻴﺭ ﻓﻲ ﺍﻟﻘﺴﻡ ‪ ،Managed Heap‬ﺒﻴﻨﻤﺎ ﺘﺴـﺘﻘل ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ‬ ‫)‪ Age‬ﻭ 2‪ (Age‬ﺒﻘﻴﻤﻬﺎ ﻓﻲ ﻤﻨﺎﻁﻕ ﻤﺨﺘﻠﻔﺔ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ.‬ ‫ﻣﻼﺣﻈﺔ‬ ‫ﻣﺆﺷﺮات اﻟﻤﺘﻐﻴﺮات اﻟﻤﺮﺟﻌﻴﺔ )اﻟﻤﻮﺟﻮدة ﻓﻲ ﻗﺴﻢ ‪ (Stack‬ﺣﺠﻤﻬﺎ 4 ﺑﺎﻳﺖ‬ ‫ﻣﻬﻤﺎ اﺧﺘﻠﻒ ﻧﻮع اﻟﻘﻴﻢ اﻟﺘﻲ ﺗﺸﻴﺮ ﻟﻬﺎ.‬ ‫ﺍﻟﻌﺒﺎﺭﺓ ‪:Option Strict‬‬ ‫ﻋﻠﻰ ﻤﺭ ﺍﻻﺠﻴﺎل ﺍﻟﺴﺎﺒﻘﺔ ﻤﻥ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ، ﻭﺍﺠﻪ ﺍﻟﻤﺒﺭﻤﺠﻭﻥ ﻤﻌﺎﻨﺎﺓ ﻜﺒﻴﺭﺓ ﻓـﻲ ﻤﺴـﺄﻟﺔ ﺘﺤﻭﻴـل ﺍﻟﺒﻴﺎﻨـﺎﺕ‬ ‫ﺍﻟﻤﺨﺘﻠﻔﺔ ﻤﻥ ﺍﻟﻘﻴﻡ. ﻤﻊ ﺫﻟﻙ، ﻟﻥ ﺘﻭﺍﺠﻪ ﺍﻱ ﻤﺸﺎﻜل ﻋﻨﺩ ﺍﺘﺒـﺎﻉ ﺍﺴـﻠﻭﺏ ﺍﻟﺘﺤﻭﻴـل ﺍﻟﻭﺍﺴـﻊ ‪Widening‬‬ ‫‪ ،Conversion‬ﺤﻴﺙ ﺍﻥ ﺍﻟﺘﺤﻭﻴل ﺍﻟﻭﺍﺴﻊ ﻴﻘﻭﻡ ﺒﻨﺴﺦ ﻗﻴﻤﺔ ﻤﻥ ﻨﻭﻉ ﺼﻐﻴﺭ )‪ Short‬ﻤﺜﻼ( ﺍﻟﻰ ﻨـﻭﻉ ﺍﻜﺒـﺭ‬ ‫ﻤﻨﻪ ) ﻜـ ‪ (Double‬ﻤﻤﺎ ﻻ ﻴﺅﺩﻱ ﺍﻟﻰ ﺍﻟﺘﻀﺤﻴﺔ ﺒﺩﻗﺔ ﺍﻟ ﻘﻴﻤﺔ:‬ ‫01 = ‪Dim A As Short‬‬ ‫ﻻ ﻣﺸﻜﻠ ﺔ ' ‪Dim B As Double = A‬‬ ‫01 ' )‪ArabicConsole.WriteLine(A‬‬ ‫01 ' )‪ArabicConsole.WriteLine(B‬‬
  • 73.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫74‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻭﻋﻠﻰ ﺍﻟﻌﻜﺱ ﻤﻥ ﺫﻟﻙ، ﻟﻭ ﻜﺎﻥ ﻟﺩﻴﻨﺎ ﻤﺘﻐﻴﺭ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Double‬ﻭﺍﺭﺩﺕ ﺍﺴـﻨﺎﺩ ﻗﻴﻤﺘـﻪ ﺍﻟـﻰ ﻤﺘﻐﻴـﺭ‬ ‫ﺍﺨﺭ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ ،Single‬ﺴﺘﻔﻘﺩ ﻫﺫﻩ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﺩﻗﺔ ﺍﻟﻌﺩﺩﻴﺔ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﻤﺘﻐﻴﺭ ﺍﻟﺴـﺎﺒﻕ، ﺍﻟﺴـﺒﺏ ﻭﺍﻀـﺢ‬ ‫ﻻﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Double‬ﺘﺴﺘﻁﻴﻊ ﺤﻤل ﻗﻴﻡ ﺍﻜﺜﺭ ﺩﻗﺔ ﻤﻥ ﺍﻟﻨﻭﻉ ‪:Single‬‬ ‫9999999.3 = ‪Dim A As Double‬‬ ‫‪Dim B As Single = A‬‬ ‫9999999.3 '‬ ‫4 '‬ ‫)‪ArabicConsole.WriteLine(A‬‬ ‫)‪ArabicConsole.WriteLine(B‬‬ ‫ﻓﻲ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ، ﻴﻀﻁﺭ ‪ Visual Basic .NET‬ﺍﻟﻰ ﺍﺠﺭﺍﺀ ﻋﻤﻠﻴﺔ ﺍﻟﺘﺤﻭﻴل ﺍﻟﺘﻠﻘﺎﺌﻴﺔ ﺤﺘـﻰ ﻻ ﻴﺘﻌـﺩﻯ‬ ‫ﺤﺩﻭﺩ ﻤﺠﺎل ﺍﻟﻘﻴﻡ ﺍﻟﺘﻲ ﺘﺴﻤﺢ ﻟﻠﻤﺘﻐﻴﺭﺍﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Single‬ﺤﻤﻠﻬﺎ، ﻤﻤﺎ ﻴﺅﺩﻱ ﺍﻟﻰ ﺍﻟﺘﻀـﺤﻴﺔ ﺒﺩﻗـﺔ ﺍﻟـﺭﻗﻡ‬ ‫ﺍﻟﻤﺤﻔﻭﻅـﺔ ﻓـﻲ ﺍﻟﻨـﻭﻉ ‪ .Double‬ﻴﻌـﺭﻑ ﻫـﺫﺍ ﺍﻟﻨـﻭﻉ ﻤـﻥ ﺍﻟﺘﺤﻭﻴـل ﺒﺎﻟﺘﻀـﻴﻴﻕ ‪Narrowing‬‬ ‫‪ ،Conversion‬ﺍﻱ ﺍﻨﻙ ﺘﻀﻴﻕ ﺍﻟﻘﻴﻤﺔ ﻤﻥ ﻤﺘﻐﻴﺭ ﻜﺒﻴﺭ )ﻜـ ‪ (Double‬ﺍﻟﻰ ﻤﺘﻐﻴﺭ ﺍﺼـﻐﺭ ﻤﻨـﻪ )ﻭﻫـﻭ‬ ‫‪ .(Single‬ﺍﻤﺜﻠﺔ ﺍﺨﺭﻯ: ﺍﻟﺘﺤﻭﻴل ﻤﻥ ‪ Long‬ﺍﻟﻰ ‪ Integer‬ﺍﻟﻰ ‪ Short‬ﺍﻟﻰ ‪... Byte‬ﺍﻟﺦ.‬ ‫ﺍﻟﺘﻀﻴﻴﻕ ﺴﺒﺏ ﺭﺌﻴﺴﻲ ﻻﻤﺭﺍﺽ ﺍﻟﺒﺭﺍﻤﺞ )ﺍﻟﺸﻭﺍﺌﺏ ‪ ،(Bugs‬ﺍﻻ ﺍﻨـﻙ ﺘﺴـﺘﻁﻴﻊ ﺍﺴـﺘﺨﺩﺍﻡ ﺍﻟﻌﺒـﺎﺭﺓ‬ ‫‪ Option Strict On‬ﻓﻲ ﺍﻋﻠﻰ ﺍﻟﻤﻠﻑ ﺤﺘﻰ ﺘﻤﻨﻊ ﻨﻔﺴﻙ ﻜﻤﺒﺭﻤﺞ ﻭ ‪ Visual Basic .NET‬ﻜﻤﺘﺭﺠﻡ ﻤﻥ‬ ‫ﺍﺠﺭﺍﺀ ﻋﻤﻠﻴﺔ ﺍﻟﺘﻀﻴﻴﻕ ﺍﻟﺘﻠﻘﺎﺌﻴﺔ ﺒﻴﻥ ﺍﻻﻨﻭﺍﻉ ﺍﻟﻤﺨﺘﻠﻔﺔ ﻤﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ، ﻟﺫﻟﻙ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ ﺴﺘﻅﻬﺭ ﻟـﻙ ﺭﺴـﺎﻟﺔ‬ ‫ﺨﻁﺄ ﺍﻥ ﻜﺎﻨﺕ ﺍﻟﻌﺒﺎﺭﺓ ‪ Option Strict On‬ﻤﺴﻁﻭﺭﺓ:‬ ‫ﻣﻨﻊ ﻋﻤﻠﻴ ﺔ اﻟﺘ ﻀﻴﻴ ﻖ '‬ ‫‪Option Strict On‬‬ ‫1‪Module Module‬‬ ‫)(‪Sub Main‬‬ ‫1 = ‪Dim A As Double‬‬ ‫‪Dim B As Single‬‬ ‫اﻟﺘﺤﻮ ﻳﻞ اﻟ ﻮاﺳﻊ ﳑﻜ ﻦ '‬ ‫‪A = B‬‬ ‫رﺳﺎﻟﺔ ﺧﻄﺄ ﺑﺴﺒﺐ اﻟﺘﻀﻴ ﻴ ﻖ '‬ ‫‪B = A‬‬ ‫‪End Sub‬‬ ‫‪End Module‬‬ ‫ﻣﻼﺣﻈﺔ‬ ‫ﺗﺄﺛﻴﺮ اﻟﻌﺒﺎرة ‪ Option Strict‬ﻳﺸﻤﻞ اﻟﻤﻠﻒ اﻟﺬي ﺳﻄﺮت ﻓﻴﻪ ﻓﻘﻂ، وان اردت‬ ‫ﺷﻤﻠﻬﺎ ﻓﻲ آﺎﻓﺔ ﻣﻠﻔﺎت اﻟﻤﺸﺮوع اﻻﺧﺮى -دون اﻟﺤﺎﺟﺔ ﻟﻜﺘﺎﺑﺘﻬﺎ - ﻳﻤﻜﻨﻚ‬ ‫ﺗﻌﺪﻳﻞ اﻋﺪا دات اﻟﻤﺘﺮﺟﻢ ﻓﻲ ﻧﺎﻓﺬة ‪- Project Property Pages‬آﻤﺎ ﻓﻌﻠﻨﺎ‬ ‫ﺳﺎﺑﻘﺎ ﻣﻊ ‪) Option Explicit‬ﺷﻜﻞ 2 -2 (.‬
  • 74.
    ‫84‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻻ ﻴﻘﺘﺼﺭ ﺘﺄﺜﻴﺭ ﺍﻟﻌﺒﺎﺭﺓ ‪ Option Strict‬ﻋﻠﻰ ﺍﻟﺒﻴﺎﻨـﺎﺕ ﺍﻟﻌﺩﺩﻴـﺔ ﻓﻘـﻁ، ﺒـل ﻴﻤﺘـﺩ ﻟﻴﺼـل ﺍﻟـﻰ‬ ‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻻﺨﺭﻯ ﻜـ ‪... Boolean ،Date ،String‬ﺍﻟﺦ:‬ ‫ﳑﻜﻦ ﰲ ﺣﺎ ﻟ ﺔ '‬ ‫‪ Option Strict Off‬ﻓﻘﻂ '‬ ‫‪Dim A As String‬‬ ‫‪Dim B As Boolean‬‬ ‫"‪A = "True‬‬ ‫‪B = A‬‬ ‫ﻭﻋﻨﺩ ﺍﻟﺤﺩﻴﺙ ﻋﻥ ﺍﻟﻤﻌﺎﻤﻼﺕ، ﻋﻠﻴﻙ ﺍﻟﺘﻔﺭﻴﻕ ﺒﻴﻥ ﻤﻌﺎﻤل ﺍﻟﻘﺴـﻤﺔ ﺍﻟﺨـﺎﺹ ﺒﺎﻻﻋـﺩﺍﺩ ﺍﻟﺼـﺤﻴﺤﺔ،‬ ‫ﻭﺒﻴﻥ ﻤﻌﺎﻤل ﺍﻟﻘﺴﻤﺔ / ﻭﺍﻟﺫﻱ ﻴﺴﺘﺨﺩﻡ ﻟﻼﻋﺩﺍﺩ ﺍﻟﻌﺸﺭﻴﺔ ﻻﻥ ﻋﻤﻠﻴﺔ ﺍﻟﺘﺤﻭﻴل ﻟﻥ ﺘـﺘﻡ ﺘﻠﻘﺎﺌﻴـﹰ، ﻜﻤـﺎ ﺍﻥ ﻤﻌﺎﻤـل‬ ‫ﺎ‬ ‫ﺍﻻﺱ ^ ﻴﺤﻭل ﺍﻟﻘﻴﻡ ﺍﻟﻰ ‪:Double‬‬ ‫رﺳﺎﻟﺔ ﺧﻄ ﺄ ﰲ ﺣ ﺎﻟ ﺔ '‬ ‫‪' Option Strict On‬‬ ‫‪Dim X As Integer‬‬ ‫2 / 01 = ‪X‬‬ ‫3 ^ 2 = ‪X‬‬ ‫ﻓﻲ ﺍﻟﻤﻘﺎﺒل، ﺘﻔﻌﻴﻠﻙ ﻟﻠﻌﺒﺎﺭﺓ ‪ Option Strict On‬ﻻ ﻴﻌﻨﻲ ﺍﻨﻙ ﻻ ﺘﺴﺘﻁﻴﻊ ﺍﺴﻨﺎﺩ ﺍﻻﻨـﻭﺍﻉ ﺍﻟﻤﺨﺘﻠﻔـﺔ‬ ‫ﻤﻥ ﺍﻟﻘﻴﻡ، ﺒل ﻴﻤﻜﻨﻙ ﺍﻻﺴﺘﻤﺭﺍﺭ ﻋﻠﻰ ﺫﻟﻙ ﺸﺭﻴﻁﺔ ﺍﻥ ﺘﻜﻭﻥ ﻟﺒﻕ ﻭﺘﺴﺘﺨﺩﻡ ﺩﻭﺍل ﺍﻟﺘﺤﻭﻴل:‬ ‫ﳑﻜﻦ ﻋﻤﻞ ذﻟﻚ ﺣ ﱴ ﻟﻮ ﻓﻌﻠﺖ اﻟﻌﺒﺎ ر ة '‬ ‫‪' Option Strict On‬‬ ‫2.3 = ‪Dim X As Double‬‬ ‫)‪Dim Y As Integer = CInt(X‬‬ ‫ﻴﻌﺭﺽ ﻟﻙ ﺍﻟﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺩﻭﺍل ﺍﻟﺘﺤﻭﻴل ﻻﻨﻭﺍﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻻﺨﺭﻯ:‬ ‫ﺍﻟﺩﺍﻟﺔ‬ ‫‪CBool‬‬ ‫‪CByte‬‬ ‫‪CChar‬‬ ‫‪CDate‬‬ ‫‪CDbl‬‬ ‫‪CDec‬‬ ‫‪CInt‬‬ ‫‪CLng‬‬ ‫‪CObj‬‬ ‫‪CShort‬‬ ‫‪CSng‬‬ ‫‪CStr‬‬ ‫ﺍﻟﻘﻴﻤﺔ ﺍﻟﺘﻲ ﺘﻌﻭﺩ ﺒ ﻬﺎ‬ ‫‪Boolean‬‬ ‫‪Byte‬‬ ‫‪Char‬‬ ‫‪Date‬‬ ‫‪Double‬‬ ‫‪Decimal‬‬ ‫‪Integer‬‬ ‫‪Long‬‬ ‫‪Object‬‬ ‫‪Short‬‬ ‫‪Single‬‬ ‫‪String‬‬
  • 75.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫94‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺍﺨﻴﺭﺍ، ﻤﺎ ﺫﻜﺭﺘﻪ ﻓﻲ ﺍﻟﺴﻁﻭﺭ ﺍﻟﺴﺎﺒﻘﺔ ﺤﻭل ﺘﺄﺜﻴﺭ ﺍﻟﻌﺒﺎﺭﺓ ‪ Option Strict On‬ﻜﺎﻥ ﻤﻭﺠﻬـﺎ ﺍﻟـﻰ‬ ‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺫﺍﺕ ﺍﻟﻘﻴﻤﺔ ‪ Value Type‬ﺒﺸﻜل ﻤﺒﺎﺸﺭ، ﻭﺒﺎﻟﻨﺴـﺒﺔ ﻟﻠﻜﺎﺌﻨـﺎﺕ ﺍﻟﺤﻘﻴﻘﻴـﺔ –ﺍﻗﺼـﺩ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ‬ ‫ﺍﻟﻤﺭﺠﻌﻴﺔ ‪ - Reference Type‬ﻓﻠﻬﺎ ﺴﻭﺍﻟﻴﻑ ﻭﻋﻠﻭﻡ ﺭﺠﺎﺠﻴل ﺍﺨﺭﻯ ﻨﺫﻜﺭﻫﺎ ﻻﺤﻘﺎ ﻓـﻲ ﺍﻟﻔﺼـل ﺍﻟﺜﺎﻟـﺙ‬ ‫ﺍﻟﻔﺌﺎﺕ ﻭﺍﻟﻜﺎﺌﻨﺎﺕ ﺒﻤﺸﻴﺌﺔ ﺍﷲ.‬ ‫اﻟﺜﻮاﺑﺖ‬ ‫ﺒﺸﻜل ﺍﻓﺘﺭﺍﻀﻲ، ﺍﻟﺜﻭﺍﺒﺕ ﺍﻟﻌﺩﺩﻴﺔ ﺍﻟﺼﺤﻴﺤﺔ ﻴﺘﻌﺎﻤل ﻤﻌﻬـﺎ ﺍﻟﻤﺘـﺭﺠﻡ ﻋﻠـﻰ ﺍﻨﻬـﺎ ﻤـﻥ ﺍﻟﻨـﻭﻉ ‪،Integer‬‬ ‫ﻭﺍﻻﻋﺩﺍﺩ ﺍﻟﻌﺸﺭﻴﺔ ﻤﻥ ﺍﻟﻨﻭﻉ ‪:Double‬‬ ‫ﻗﻴﻤﺔ ﻣ ﻦ اﻟﻨ ﻮ ع ‪ArabicConole.WriteLine (10) ' Integer‬‬ ‫ﻗﻴﻤﺔ ﻣﻦ اﻟ ﻨﻮ ع ‪ArabicConole.WriteLine (5.5) ' Double‬‬ ‫ﻤﻊ ﺫﻟﻙ، ﻴﻤﻜﻨﻙ ﺘﺤﺩﻴﺩ ﻨﻭﻉ ﺍﻟﺜﺎﺒﺕ ﻟﺯﻴﺎﺩﺓ ﺴﺭﻋﺔ ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ، ﻓﺘﺴﺘﻁﻴﻊ ﺍﺴـﺘﺨﺩﺍﻡ ﺍﻟـﺫﻴل "‪ "L‬ﻟﻠﻨـﻭﻉ ‪،Long‬‬ ‫ﺍﻟﺫﻴل "‪ "S‬ﻟﻠﻨﻭﻉ ‪ ،Short‬ﺍﻟﺫﻴل "‪ "D‬ﻟﻠﻨـﻭﻉ ‪ ،Decimal‬ﻭﺍﻟـﺫﻴل "‪ "F‬ﻟﻠﻨـﻭﻉ ‪) Single‬ﺭﺍﺠـﻊ ﺒﻘﻴـﺔ‬ ‫ﺍﻻﺨﺘﺼﺎﺭﺍﺕ ﻓﻲ ﻤﻜﺘﺒﺔ ‪:(MSDN‬‬ ‫‪Dim X As Long‬‬ ‫‪Dim Y As Long‬‬ ‫001 = ‪X‬‬ ‫‪Y = 100L‬‬ ‫اﻻﺳﻨﺎد ا ﻟﺘﺎﱄ اﺳﺮع وذﻟﻚ ﻟﻌﺪم اﺟﺮاء اﻟﺘﺤ ﻮﻳﻞ ا ﻟﻮاﺳ ﻊ '‬ ‫ﻭﺒﺎﻟﻨﺴﺒﺔ ﻟﻠﺜﻭﺍﺒﺕ ﺍﻟﺘﻲ ﺘﺤﻤل ﺍﻟﻨﻭﻉ ‪ ،Date‬ﻓﻀ ﻊ ﻗﻴﻤﺔ ﺍﻟﻭﻗﺕ ﻭ/ﺃﻭ ﺍﻟﺘﺎﺭﻴﺦ ﺒﻴﻥ ﺍﻟﺭﻤﺯﻴﻥ # ﻭ #:‬ ‫‪Dim X As Date‬‬ ‫‪Dim Y As Date‬‬ ‫#3002/92/1# = ‪x‬‬ ‫#‪Y = #2/15/2003 9:30:00 PM‬‬ ‫ﻓﻜﺭﺓ ﺍﻟﺜﻭﺍﺒﺕ ﺍﻟﻤﺴﻤﺎﺓ ﺸﺒﻴﻪ ﺒﻔﻜﺭﺓ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ، ﺍﻻ ﺍﻥ ﻗﻴﻡ ﺍﻟﺜﻭﺍﺒﺕ ﺍﻟﻤﺴﻤﺎﺓ ﻻ ﻴﻤﻜـﻥ ﺘﻌـﺩﻴﻠﻬﺎ ﻭﻗـﺕ‬ ‫ﺍﻟﺘﻨﻔﻴﺫ، ﻭﺫﻟﻙ ﻻﻨﻬﺎ ﺘﺴﺘﺒﺩل ﺒﻘﻴﻤﻬﺎ ﺍﺜﻨﺎﺀ ﻋﻤﻠﻴﺔ ﺍﻟﺘﺭﺠﻤﺔ ﻟﻠﺒﺭﻨﺎﻤﺞ، ﻭﻴﺘﻡ ﺤﻔﻅﻬﺎ ﻓﻲ ﻤﻠـﻑ ﺍﻟﺒﺭﻨـﺎﻤﺞ ﺍﻟﻨﻬـﺎﺌﻲ‬ ‫)ﻜـ ‪ EXE‬ﻤﺜﻼ(. ﺍﺴﺘﺨﺩﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Const‬ﻟﺘﻌﺭﻴﻑ ﺜﺎﺒﺕ ﺠﺩﻴﺩ:‬ ‫"ﻋﺒﺎس ا ﻟﺴﺮﻳ ﻊ" = ‪Const PROGRAMMER_NAME‬‬ ‫ﻋﺒﺎس اﻟﺴﺮ ﻳ ﻊ ' )‪ArabicConsole.WriteLine(PROGRAMMER_NAME‬‬ ‫ﺘﺤﺩﻴﺩ ﻨﻭﻉ ﺍﻟﺜﺎﺒﺕ ﺍﻤﺭ ﻤﻔﻀل ﻟﺯﻴﺎﺩﺓ ﺍﻟﺴﺭﻋﺔ، ﺒﻴﻨﻤﺎ ﻴﻜـﻭﻥ ﺍﻟﺯﺍﻤـﻲ ﺍﻥ ﻓﻌﻠـﺕ ﺍﻟﻌﺒـﺎﺭﺓ ‪Option‬‬ ‫‪:Strict On‬‬ ‫"ﻋﺒﺎس ا ﻟﺴﺮﻳ ﻊ" = ‪Const PROGRAMMER_NAME As String‬‬
  • 76.
    ‫05‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻋﻭﺩﺓ ﺍﻟﻰ ﺍﻟﺜﻭﺍﺒﺕ ﺍﻟﻌﺩﻴﺔ، ﻴﻤﻜﻨﻙ ﻜﺘﺎﺒـﺔ ﺍﻻﻋـﺩﺍﺩ ﺒﺎﻟﺼـﻴﻐﺔ ﺍﻟﺴـﺕ ﻋﺸـﺭﻴﺔ ‪ Hexadecimal‬ﺍﻭ‬ ‫ﺍﻟﺜﻤﺎﻨﻴﺔ ‪ Octal‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﺭﻤﻭﺯ ‪ &H‬ﻭ ‪– &O‬ﻋﻠﻰ ﺍﻟﺘﻭﺍﻟﻲ - ﻗﺒل ﺍﻟﻌﺩﺩ:‬ ‫552 '‬ ‫ﺻﻴﻐﺔ ﺳﺖ ﻋﺸﺮﻳ ﺔ '‬ ‫)‪ArabicConsole.WriteLine(&HFF‬‬ ‫8 '‬ ‫ﺻﻴﻐﺔ ﲦﺎﻧ ﻴ ﺔ '‬ ‫)01‪ArabicConsole.WriteLine(&O‬‬ ‫ﺘﺫﻜﺭ ﺍﻥ ﺍﻻﻋﺩﺍﺩ –ﺒﺸﻜل ﺍﻓﺘﺭﺍﻀﻲ - ﺘﻜﻭﻥ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ ،Integer‬ﻟﺫﻟﻙ ﻻ ﺘﻨﺴـﻰ ﺍﺴـﺘﺨﺩﺍﻡ ﺍﻟـﺫﻴل ﺍﻟﻤﻨﺎﺴـﺏ‬ ‫ﻟﻠﻘﻴﻤﺔ ﺍﻟﻤﻨﺎﺴﺒﺔ، ﻓﺎﻟﻌﺩﺩ ﺍﻟﺘﺎﻟﻲ ﻴﻔﻀل ﺍﺴﻨﺎﺩ ﺍﻟﺫﻴل "‪ "L‬ﻟﻪ ﺤﺘﻰ ﻨﺨﺭﺝ ﺒﺎﻟﻨﺘﻴﺠﺔ ﺍﻟﻤﻨﺎﺴﺒﺔ:‬ ‫1- '‬ ‫5927694924 '‬ ‫)‪ArabicConsole.WriteLine(&HFFFFFFFF‬‬ ‫)‪ArabicConsole.WriteLine(&HFFFFFFFFL‬‬ ‫ﺍﺨﻴﺭﺍ، ﻻﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺼـﻴﻐﺔ ﺍﻟﺴـﺕ ﻋﺸـﺭﻴﺔ ‪ Hexadecimal‬ﺍﻭ ﺍﻟﺜﻤﺎﻨﻴـﺔ ‪ Octal‬ﻟﻼﻋـﺩﺍﺩ‬ ‫ﺍﻟﻌﺸﺭﻴﺔ:‬ ‫ﺑﻮدي وﻟﻜ ﻦ ﻟﻼﺳ ﻒ ﻏﲑ ﳑﻜ ﻦ '‬ ‫)52.‪ArabicConsole.WriteLine(&HFF‬‬ ‫اﻟﺘﺮآﻴﺒﺎت واﻟﻤﺼﻔﻮﻓﺎت‬ ‫ﻋﺒﺭ ﺍﻟﺯﻤﻥ ﻭﻤﻊ ﺍﻻﻴﺎﻡ، ﺴﺘﺒﺩﺃ ﺒﺘﻌﺭﻴﻑ ﺍﻨﻭﺍﻉ ﺨﺎﺼﺔ ﺒﻙ ﻓﻲ ﺒﺭﺍﻤﺠﻙ ﺍﻟﺠﺩﻴـﺔ ﺘﻌـﺭﻑ ﺒﺎﻟﺘﺭﻜﻴﺒـﺎﺕ، ﻭﺍﻟﺘـﻲ‬ ‫ﻴﺩﻋﻤﻬﺎ ‪ Visual Basic .NET‬ﺒﻘﻭﺓ. ﻓﻲ ﻫﺫﺍ ﺍﻟﻘﺴﻡ ﻤﻥ ﺍﻟﻔﺼل ﺴـﺄﺘﺤﺩﺙ ﻋـﻥ ﺍﻟﺘﺭﻜﻴﺒـﺎﺕ ﻤـﻥ ﻨـﻭﻉ‬ ‫‪ Enum‬ﻭﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻤﻥ ﻨﻭﻉ ‪ ،Structure‬ﻜﻤﺎ ﺴﺄﺨﺼﺹ ﻓﻘﺭﺓ ﻜﺎﻤﻠﺔ ﺤﻭل ﺍﻟﻤﺼﻔﻭﻓﺎﺕ.‬ ‫اﻟﺘﺮآﻴﺒﺎت ﻣﻦ ﻧﻮع ‪Enum‬‬ ‫ﻴﻤﻜﻨﻙ ﺘﻌﺭﻴﻑ ﻨﻭﻉ ﻤﻌﻴﻥ ﻤﻥ ﺍﻨﻭﺍﻉ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺒﺤﻴﺙ ﺘﺤﺼﺭ ﻤﺠﺎل ﺍﻟﻘﻴﻡ ﺍﻟﺘﻲ ﺘﺴـﻨﺩﻫﺎ ﺍﻟﻴﻬـﺎ ﺘﻌـﺭﻑ ﺒﺎﻟــ‬ ‫‪ .Enumeration‬ﺍﺴﺘﺨﺩﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Enum‬ﻟﺘﻌﺭﻴﻑ ﺘﺭﻜﻴﺏ ﺠﺩﻴـﺩ ﺍﻤـﺎ ﻋﻠـﻰ ﻤﺴـﺘﻭﻯ ﺍﻟﻭﺤـﺩﺓ‬ ‫ﺍﻟﺒﺭﻤﺠﻴﺔ ‪ ،Module‬ﺍﻭ ﺨﺎﺭﺝ ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ، ﺍﻭ ﺩﺍﺨل ﺘﺭﻜﻴﺏ ﺍﺨـﺭ ﻭﻟﻜـﻥ ﻤـﻥ ﺍﻟﻨـﻭﻉ ‪.Structure‬‬ ‫ﻫﺫﺍ ﺍﻟﻤﺜﺎل ﻋﺭﻓﺕ ﻓﻴﻪ ﺘﺭﻜﻴﺏ ﻴﻤﺜل ﺍﻴﺎﻡ ﺍﻻﺴﺒﻭﻉ:‬ ‫‪Enum Day‬‬ ‫‪Saturday‬‬ ‫‪Sunday‬‬ ‫‪Monday‬‬ ‫‪Tuesday‬‬ ‫‪Wednesday‬‬ ‫‪Thursday‬‬ ‫‪Friday‬‬ ‫‪End Enum‬‬
  • 77.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫15‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻭﺍﻻﻥ ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺘﺭﻜﻴﺏ ﺍﻟﺴﺎﺒﻕ ﻭﺘﻌﺭﻴﻑ ﻤﺘﻐﻴﺭﺍﺕ ﺠﺩﻴﺩﻩ ﻤﻨﻪ:‬ ‫‪Dim x As Day‬‬ ‫‪Dim y As Day‬‬ ‫‪x = Day.Friday‬‬ ‫‪y = x‬‬ ‫ﻣﻼﺣﻈﺔ‬ ‫ﺗﻘﻨﻴﺎ، ﺗ ﺼﻨﻒ اﻟﺘﺮآﻴﺒﺎت ﻣﻦ اﻟﻨﻮع ‪ Enum‬ﺿـﻤﻦ اﻟﺜﻮاﺑـﺖ، ﻓﻬـﻲ آﺎﻟﺜﻮاﺑـﺖ‬ ‫اﻟﻤﺴﻤﺎة -اﻟﺘﻲ ﺗﻄﺮﻗﺖ ﻟﻬﺎ ﺳﺎﺑﻘﺎ - ﺣﻴﺚ ان ﻗﻴﻤﻬﺎ ﺗﺴﺘﺒﺪل اﺛﻨـﺎء ﻋﻤﻠﻴـﺔ‬ ‫اﻟﺘﺮﺟﻤﺔ.‬ ‫ﻋﻤﻠﻴﺎ، ﺴﺘﺴﺘﺨﺩﻡ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻤﻥ ﻨﻭﻉ ‪ Enum‬ﻜﻭﺴﻴﻁﺎﺕ ﺘﺭﺴﻠﻬﺎ ﺍﻟﻰ ﺍﻻﺠﺭﺍﺀﺍﺕ:‬ ‫)‪Sub ShowDay(ByVal CurrentDay As Day‬‬ ‫‪If CurrentDay = Day.Friday Then‬‬ ‫)"اﺟﺎز ة"(‪ArabicConsole.WriteLine‬‬ ‫‪End If‬‬ ‫…‬ ‫…‬ ‫‪End Sub‬‬ ‫ﺜﻡ ﺘﺭﺴل ﺍﻟﻴﻬﺎ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻤﻥ ﻨﻔﺱ ﻨﻭﻉ ﺍﻟﺘﺭﻜﻴﺏ ﺍﻭ ﻗﻴﻡ ﺍﻟﺘﺭﻜﻴﺏ ﻤﺒﺎﺸﺭﺓ:‬ ‫‪Dim X As Day‬‬ ‫‪X = Day.Friday‬‬ ‫)‪ShowDay(X‬‬ ‫)‪ShowDay(Day.Friday‬‬ ‫ﺘﺒﺩﺃ ﻗﻴﻡ ﻋﻨﺎﺼﺭ ﺍﻟﺘﺭﻜﻴﺏ ﻤﻥ ﺍﻟﺭﻗﻡ 0، ﻤﻊ ﺫﻟﻙ ﻴﻤﻜﻨﻙ ﺘﺨﺼﻴﺹ ﻗﻴﻡ ﺍﺨﺭﻯ ﺒﻜل ﺍﻨﺴﻴﺎﺒﻴﺔ:‬ ‫‪Enum Day‬‬ ‫01 = ‪Saturday‬‬ ‫02 = ‪Sunday‬‬ ‫‪Monday‬‬ ‫‪Tuesday‬‬ ‫‪Wednesday‬‬ ‫‪Thursday‬‬ ‫‪Friday‬‬ ‫‪End Enum‬‬ ‫ﻤﻊ ﺍﻟﻌﻠﻡ ﺍﻥ ﻤﻘﺩﺍﺭ ﺍﻟﺯﻴﺎﺩﺓ ﻟﺒﺎﻗﻲ ﻋﻨﺎﺼﺭ ﺍﻟﺘﺭﻜﻴﺏ ﻫﻭ ﻭﺍﺤـﺩ. ﺃﻱ ﺃﻥ ‪ Monday‬ﺴـﻴﺤﻤل ﺍﻟﻘﻴﻤـﺔ 12، ﻭ‬ ‫‪ Tuesday‬ﺴﻴﺤﻤل ﺍﻟﻘﻴﻤﺔ 22، ... ﻭﻫﻜﺫﺍ.‬
  • 78.
    ‫25‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺠﻤﻴﻊ ﺍﻟﻘﻴﻡ ﺍﻟﺘﻲ ﻋﺭﻓﺘﻬﺎ ﻓﻲ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﺍﻟﺴﺎﺒﻘﺔ ﻫﻲ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ ،Integer‬ﻤﻊ ﺫﻟـﻙ ﻴﻤﻜﻨـﻙ ‪Visual‬‬ ‫‪ Basic .NET‬ﻤﻥ ﺘﻐﻴﻴﺭﻫﺎ ﺍﻟﻰ ‪ ،Short ،Byte‬ﺍﻭ ‪ Long‬ﺭﻏﻡ ﺍﻥ ﻤﺴﺘﻨﺩﺍﺕ ‪ .NET‬ﻻ ﺘﻨﺼﺤﻙ ﺒﻌﻤـل‬ ‫ﺫﻟﻙ ﺍﻻ ﻋﻨﺩ ﻭﺠﻭﺩ ﺴﺒﺏ ﻤﻘﻨﻊ ﻟﻌﻤل ﺫﻟﻙ:‬ ‫‪Enum Day As Long‬‬ ‫‪Saturday‬‬ ‫‪Sunday‬‬ ‫…‬ ‫…‬ ‫‪End Enum‬‬ ‫ﻭﻟﻠﺤﺩﻴﺙ ﻋﻥ ﻤﺩﻯ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ، ﻓﺎﺨﺘﺼﺭ ﻋﻠﻴﻙ ﺍﻟﻜﻼﻡ ﺒـﺎﻟﻘﻭل: ﺍﻥ ﻋﺭﻓـﺕ ﺍﻟﺘﺭﻜﻴـﺏ‬ ‫ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ ،Private‬ﻓﺎﻥ ﻤﺩﻯ ﻫﺫﺍ ﺍﻟﺘﺭﻜﻴﺏ ﺴﻴﻜﻭﻥ ﻤﺤﺼﻭﺭﺍ ﺩﺍﺨـل ﺍﻟﻭﺤـﺩﺓ ﺍﻟﺒﺭﻤﺠﻴـﺔ‬ ‫ﹰ‬ ‫ﺍﻟﺫﻱ ﻋﺭﻑ ﻓﻴﻬﺎ ﻫﺫﺍ ﺍﻟﺘﺭﻜﻴﺏ، ﺍﻤﺎ ﺍﻥ ﺍﺴﺘﺨﺩﻤﺕ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Public‬ﺍﻭ ﺤﺘـﻰ ﺘﺠﺎﻫﻠﺘﻬـﺎ ﻓﺴـﻴﻜﻭﻥ‬ ‫ﺍﻟﻤﺩﻯ ﺸﺎﻤﻼ ﻟﺒﺎﻗﻲ ﻤﻠﻔﺎﺕ ﺍﻟﻤﺸﺭﻭﻉ:‬ ‫ﹰ‬ ‫1‪Module Module‬‬ ‫ﻋﺎم '‬ ‫‪Enum GlobalEnum‬‬ ‫1‪Enum‬‬ ‫2‪Enum‬‬ ‫…‬ ‫‪End Enum‬‬ ‫ﻋﺎم اﻳﻀ ﺎ '‬ ‫2‪Public Enum GlobalEnum‬‬ ‫1‪Enum‬‬ ‫2‪Enum‬‬ ‫…‬ ‫‪End Enum‬‬ ‫ﻋﻠﻰ ﻣﺴ ﺘﻮى ا ﻟﻮﺣﺪة اﻟﱪﳎ ﻴ ﺔ'‬ ‫‪Private Enum PrivateEnum‬‬ ‫1‪Enum‬‬ ‫2‪Enum‬‬ ‫…‬ ‫‪End Enum‬‬ ‫…‬ ‫…‬ ‫‪End Module‬‬ ‫ﻣﻼﺣﻈﺔ‬ ‫ﻳﻤﻜﻨﻚ اﻳ ﻀﺎ ﺗﻌﺮﻳﻒ اﻟﺘﻜﺮﻳﺒﺎت ﻣﻦ ﻧﻮع ‪ Enum‬ﺧﺎرج اﻟﻮﺣـﺪات اﻟﺒﺮﻣﺠﻴـﺔ، اﻻ‬ ‫اﻧﻚ ﻟﻦ ﺗﺴﺘﻄﻴﻊ اﺳﺘﺨﺪام اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ Priv ate‬ﻓﻲ هﺬﻩ اﻟﺤﺎﻟﺔ. اﻣﺎ‬ ‫ان ﻋﺮﻓﺖ اﻟﺘﺮآﻴﺒﺎت ﻣـﻦ ﻧـﻮع ‪ Enum‬داﺧـﻞ ﺗﺮآﻴﺒـﺎت ﻣـﻦ ﻧـﻮع ‪Structure‬‬ ‫ﻓﺎﻟﻮ ﺿﻊ ﺳﻴﻜﻮن ﻣﺜﻞ ﻣﺎ آﺎن ﻋﻠﻴﻪ ﻣﻊ اﻟﻮﺣﺪات اﻟﺒﺮﻣﺠﻴﺔ.‬
  • 79.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫35‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺍﻟﻤﺯﻴﺩ ﺍﻴﻀﺎ، ﺘﺴﺘﻁﻴﻊ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Friend‬ﻭﺍﻟﺘﻲ ﺘﻤﺎﺜل ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠـﻭﺯﺓ ‪،Public‬‬ ‫ﺍﻻ ﺍﻥ ﺍﻻﻭﻟﻰ ﻻ ﺘﺴﻤﺢ ﻟﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺘﺭﻜﻴﺏ ﻤﻥ ﺨﺎﺭﺝ ﺤﺩﻭﺩ ﺍﻟﻤﺸﺭﻭﻉ.‬ ‫اﻟﺘﺮآﻴﺒﺎت ﻣﻦ ﻧﻮع ‪Structure‬‬ ‫ﻴﻌﺭﻑ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﺒﺎﻻﻨﻭﺍﻉ ﺍﻟﻤﻌﺭﻓـﺔ ﻤـﻥ ﻗﺒـل ﺍﻟﻤﺴـﺘﺨﺩﻡ ‪– User Defined Types‬‬ ‫)‪ ،(UDT‬ﺒﺤﻴﺙ ﺘﻤﻜﻨﻙ ﻤﻥ ﺩﻤﺞ ﺍﻨﻭﺍﻉ ﻤﺨﺘﻠﻔﺔ ﻤﻥ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﻭﻀـﻤﻬﺎ ﻓـﻲ ﺘﺭﻜﻴـﺏ ﺍﻭ ﻜﺘﻠـﺔ ﻭﺍﺤـﺩﺓ.‬ ‫ﺍﺴﺘﺨﺩﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Structure‬ﻟﺘﻌﺭﻴﻑ ﺘﺭﻜﻴﺏ ﺠﺩﻴﺩ:‬ ‫‪Structure Person‬‬ ‫‪Dim Name As String‬‬ ‫‪Dim Age As Integer‬‬ ‫‪End Structure‬‬ ‫ﺜﻡ ﺘﻌﺭﻑ ﻤﺘﻐﻴﺭﺍﺕ ﺠﺩﻴﺩﺓ ﻤﻥ ﻫﺫﺍ ﺍﻟﺘﺭﻜﻴﺏ ﻭﺘﺘﻌﺎﻤل ﻤﻌﻬﺎ ﻜﺎﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﺩﻴﺔ:‬ ‫‪Dim Turki As Person‬‬ ‫"ﺗﺮآﻲ اﻟﻌﺴﲑ ي" = ‪Turki.Name‬‬ ‫99 = ‪Turki.Age‬‬ ‫ﺗﺮآﻲ اﻟﻌﺴ ﲑ ي ' )‪ArabicConsole.WriteLine(Turki.Name‬‬ ‫99 ' )‪ArabicConsole.WriteLine(Turki.Age‬‬ ‫ﺍﻟﻤﺯﻴﺩ ﺍﻴﻀﺎ، ﻴﻤﻜﻨﻙ ﻨﺴﺦ ﻗﻴﻡ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﺒﺎﻨﺴﻴﺎﺒﻴﺔ ﻜﺎﻤﻠﺔ ﻜﻤﺎ ﺘﻔﻌل ﻤﻊ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺍﻟﻌﺎﺩﻴـﺔ، ﺸـﺭﻴﻁﺔ‬ ‫ﺍﻥ ﺘﻜﻭﻥ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻤﺘﻁﺎﺒﻘﺔ:‬ ‫‪Dim Turki2 As Person‬‬ ‫‪Turki2 = Turki‬‬ ‫ﺗﺮآﻲ اﻟﻌﺴﲑ ي ' )‪ArabicConsole.WriteLine(Turki2.Name‬‬ ‫99 ' )‪ArabicConsole.WriteLine(Turki2.Age‬‬ ‫ﺒﻌﻀﺎ:‬ ‫ﻻ ﺘﻨﺴﻰ ﺍﻥ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻤﻥ ﻨﻭﻉ ‪ Structure‬ﻴﻤﻜﻥ ﺍﻥ ﺘﻜﻭﻥ ﻤﺘﺩﺍﺨﻠﺔ ‪ ،Nested‬ﺍﻱ ﻴﺤﺘـﻭﻱ ﺒﻌﻀـﻬﺎ‬ ‫‪Structure Person‬‬ ‫‪Structure AddressStruct‬‬ ‫‪Dim City As String‬‬ ‫‪Dim Countrey As String‬‬ ‫‪End Structure‬‬ ‫‪Dim Name As String‬‬ ‫‪Dim Age As Integer‬‬ ‫‪Dim Address As AddressStruct‬‬ ‫‪End Structure‬‬
  • 80.
    ‫45‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﻋﻨﺎﺼﺭ ﺍﻟﺘﺭﻜﻴﺏ ﺍﻟﻤﺤﻀﻭﻥ ﻴﺘﻡ ﻤﻥ ﺨﻼل ﺍﻟﺘﺭﻜﻴﺏ ﺍﻟﺤﺎﻀﻥ ﻟﻬﺎ ﺒﻜل ﻤﻨﻁﻘﻴﺔ:‬ ‫‪Dim Turki As Person‬‬ ‫"ﺗﺮآﻲ اﻟﻌﺴﲑ ي" = ‪Turki.Name‬‬ ‫99 = ‪Turki.Age‬‬ ‫"اﻟﻈﻬﺮا ن" = ‪Turki.Address.City‬‬ ‫"اﳌﻤﻠﻜﺔ اﻟﻌﺮﺑ ﻴﺔ اﻟ ﺴﻌﻮدﻳ ﺔ" = ‪Turki.Address.Countrey‬‬ ‫ﺒﺎﻻﻀﺎﻓﺔ ﺍﻟﻰ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ، ﻋﻠﻴﻙ ﻤﻌﺭﻓﺔ ﺍﻥ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻤﻥ ﻨـﻭﻉ ‪ Structure‬ﻓـﻲ ‪Visual Basic‬‬ ‫‪ .NET‬ﻫﻲ ﺘﺭﻜﻴﺒﺎﺕ ﻤﻁﻭﺭﺓ ﻭﻤﺭﻨﺔ ﺠﺩﺍ )ﻤﺜل ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﻟﻐﺔ ++‪ ،(C‬ﻓﻬـﻲ ﺘﻤﻜﻨـﻙ ﻤـﻥ‬ ‫ﺘﻌﺭﻴﻑ ﻋﻨﺎﺼﺭ ﺍﻀﺎﻓﻴﺔ ﻓﻲ ﺩﺍﺨل ﺍﻟﺘﺭﻜﻴﺏ ﻜﺎﻟﻁﺭﻕ ‪ Methods‬ﻭﺍﻟﺨﺼﺎﺌﺹ ‪:Properties‬‬ ‫‪Structure Person‬‬ ‫‪Dim Name As String‬‬ ‫‪Dim Age As Integer‬‬ ‫ﺗﻌﺮﻳﻒ ﻃ ﺮﻳﻘ ﺔ '‬ ‫)(‪Sub ShowData‬‬ ‫)‪ArabicConsole.WriteLine(Name‬‬ ‫)‪ArabicConsole.WriteLine(Age‬‬ ‫‪End Sub‬‬ ‫‪End Structure‬‬ ‫ﻤﺭﺓ ﺍﺨﺭﻯ، ﻴﻤﻜﻨﻙ ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﻋﻨﺎﺼﺭ ﺍﻟﺘﺭﻜﻴﺏ ﻭﺍﺴﺘﺩﻋﺎﺀ ﻁﺭﻗﻪ ﺒﻨﻔﺱ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻻﻨﺴﻴﺎﺒﻴﺔ:‬ ‫‪Dim Turki As Person‬‬ ‫"ﺗﺮآﻲ اﻟﻌﺴﲑ ي" = ‪Turki.Name‬‬ ‫99 = ‪Turki.Age‬‬ ‫)(‪Turki.ShowData‬‬ ‫اﻧﻈﺮ اﻳﻀﺎ‬ ‫ﺳﺄﺗﻨﺎول اﻟﻄﺮق واﻟﺨ ﺼـﺎﺋﺺ ﺑﺸـﻜﻞ ﻣﻔ ﺼـﻞ ﻓـﻲ اﻟﻔ ﺼـﻞ اﻟﺜﺎﻟـﺚ اﻟﻔﺌـﺎت‬ ‫واﻟﻜﺎﺋﻨﺎت.‬ ‫ﻻ ﺍﺭﻴﺩ ﺍﻥ ﺍﺸﺘﺕ ﺘﻔﻜﻴﺭﻙ ﺍﻻﻥ ﺒﻤﻭﻀﻭﻉ ﺍﻟﻁﺭﻕ ﻭﺍﻟﺨﺼﺎﺌﺹ ) ﻓﻬﻲ ﺤـﺩﻴﺙ ﺍﻟﻔﺼـل ﺍﻟﺜﺎﻟـﺙ ﻜﻤـﺎ‬ ‫ﺫﻜﺭﺕ ﻓﻲ ﺍﻟﻤﺭﺒﻊ ﺍﻻﻋﻠﻰ(، ﻭﻟﻜﻥ ﺩﻋﻨﻲ ﺍﻟﻤﺢ ﻟﻙ ﻫﻨـﺎ ﺍﻥ ﺍﻟﻤﺸـﻴﺩﺍﺕ ‪ Constructers‬ﻤﺩﻋﻭﻤـﺔ ﺒﺸـﻜل‬ ‫ﻤﺨﻔﻲ ﻓﻲ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ .Structure‬ﻴﺎ ﺍﻟﻬﻰ! ﻤﺎﺫﺍ ﺘﻘﺼﺩ ﻴﺎ ﺘﺭﻜـﻲ ﺒﻜﻠﻤـﺔ ﻤﺨﻔـﻲ؟! ﺍﻗﺼـﺩ ﻴـﺎ‬ ‫ﻋﺯﻴﺯﻱ ﺍﻥ ﺍﻻﺠﺭﺍﺀ ‪ Sub New‬ﻤﻌﺭﻑ ﺒﺸﻜل ﺘﻠﻘﺎﺌﻲ ﻓﻲ ﺍﻟﺘﺭﻜﻴﺏ ﺩﻭﻥ ﺍﻥ ﺘﺭﺍﻫـﺎ. ﻭﻟﻤـﺎﺫﺍ ﺘـﻡ ﺍﺨﻔﺎﺌـﻪ؟‬ ‫ﺍﻟﺴﺒﺏ ﻴﺎ ﺴﻴﺩﻱ ﺘﻘﻨﻲ ﺒﺤﺕ ﻭﻻ ﺍﻭﺩ ﺍﻥ ﺍﺒﻴﻨﻪ ﺍﻻ ﻓﻲ ﺍﻟﻔﺼﻭل ﺍﻟﻼﺤﻘـﺔ. ﺤﺴـﻨﺎ ﻭﻤـﺎ ﺍﻟﻔﺎﺌـﺩﺓ ﻤﻨـﻪ؟ ﺍﻟﻔﺎﺌـﺩﺓ‬ ‫ﺒﺒﺴﺎﻁﺔ ﺍﺴﻨﺎﺩ ﻗﻴﻡ ﺍﺒﺘﺩﺍﺌﻴﺔ ﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﺘﺭﻜﻴﺏ، ﻓﻠﻭ ﺤﺎﻭﻟﺕ ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ ﻭﻗﺕ ﺍﻟﺘﺼﺭﻴﺢ ﻜﻤﺎ ﻓﻌﻠﻨـﺎ ﺴـﺎﺒﻘﺎ ﻋﻨـﺩ‬ ‫ﺍﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ:‬
  • 81.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫55‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫‪Structure MyStruct‬‬ ‫0 = ‪Dim x As Integer‬‬ ‫01 = ‪Dim y As Integer‬‬ ‫…‬ ‫…‬ ‫‪End Structure‬‬ ‫ﺴﻴﻅﻬﺭ ﻟﻙ ﺍﻟﻤﺘﺭﺠﻡ ﺭﺴﺎﻟﺔ ﺨﻁﺄ ﺘﻔﻴﺩ ﺒﺎﻨﻙ ﻻ ﺘﺴﺘﻁﻴﻊ ﻓﻌل ﺫﻟﻙ )ﺭﻏﻡ ﺍﻨﻲ ﻟﻡ ﺍﺠﺩ ﺴـﺒﺏ ﻤﻨﻁﻘـﻲ ﻤﻘﻨـﻊ ﻻ‬ ‫ﻴﺴﻤﺢ ﻟﻲ ﺒﻔﻌل ﺫﻟﻙ(، ﻭﻫﻨﺎ ﻴﺄﺘﻲ ﺩﻭﺭ ﺍﻟﻤﺸـﻴﺩ ﺍﻟﻤﺨﻔـﻲ ‪ Sub New‬ﺍﻟـﺫﻱ ﻴﻘـﻭﻡ ﺒﺎﺴـﻨﺎﺩ ﻗـﻴﻡ ﺍﺒﺘﺩﺍﺌﻴـﺔ‬ ‫ﻟﻠﻤﺘﻐﻴﺭﺍﺕ )0 ﻟﻠﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺩﺩﻴﺔ، ﻻ ﺸﺊ ﻟﻠﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﺤﺭﻓﻴﺔ، ﻭﺍﻟﻘﻴﻤﺔ ‪ Nothing‬ﻟﻠﻜﺎﺌﻨـﺎﺕ(. ﻤـﻊ ﺫﻟـﻙ،‬ ‫ﻴﻤﻜﻨﻙ ﺘﻌﺭﻴـﻑ ﻤﺸـﻴﺩ ‪ Sub New‬ﺒﻨﻔﺴـﻙ ﻋـﻥ ﻁﺭﻴـﻕ ﺘﻁﺒﻴـﻕ ﻤﺒـﺩﺃ ﻴﻌـﺭﻑ ﺒﺎﻋـﺎﺩﺓ ﺍﻟﺘﻌﺭﻴـﻑ‬ ‫‪) Overloading‬ﻭﻫﻭ ﺤﺩﻴﺙ ﺍﻟﻔﺼل ﺍﻟﺜﺎﻟﺙ ﺍﻴﻀﺎ(. ﻟﻌﻤل ﺫﻟﻙ، ﺍﻀﻑ ﻭﺴـﻴﻁﺎﺕ ‪ Parameters‬ﺍﻀـﺎﻓﻴﺔ‬ ‫ﻤﻊ ﺍﻻﺠﺭﺍﺀ ‪:Sub New‬‬ ‫‪Structure Person‬‬ ‫‪Dim Name As String‬‬ ‫‪Dim Age As Integer‬‬ ‫اﺟﺮاء ﲤﺖ اﻋ ﺎدة ﺗ ﻌﺮﻳﻔ ﻪ ‪' Overload‬‬ ‫)‪Sub New(ByVal PersonName As String‬‬ ‫‪Name = PersonName‬‬ ‫)"ﰎ ﺗﻨ ﻔﻴﺬ ا ﳌﺸﻴ ﺪ"(‪ArabicConsole.WriteLine‬‬ ‫‪End Sub‬‬ ‫‪End Structure‬‬ ‫ﺭﻏﻡ ﺍﻥ ﺍﻟﻭﻅﻴﻔﺔ ﺍﻷﺴﺎﺴﻴﺔ ﻟﻼﺠﺭﺍﺀ ‪ Sub New‬ﻫﻲ ﺍﻟﻌﻤل ﻜﻤﺸـﻴﺩ، ﺍﻻ ﺍﻨـﻪ ﻟـﻥ ﻴـﺘﻡ ﺍﺴـﺘﺩﻋﺎﺌﻪ‬ ‫ﺒﻤﺠﺭﺩ ﺍﻨﺸﺎﺀ ﻜﺎﺌﻥ ﻤﻥ ﺍﻟﺘﺭﻜﻴﺏ ﻓﻴﻤﺎ ﻟﻭ ﺼﺭﺤﺕ ﻋﻥ ﻤﺘﻐﻴﺭ ﺠﺩﻴﺩ ﺒﺎﻟﻁﺭﻕ ﺍﻟﺘﻘﻠﻴﺩﻴـﺔ، ﻭﺍﻟـﺩﻟﻴل ﺠـﺭﺏ ﻫـﺫﺍ‬ ‫ﺍﻟﺴﻁﺭ:‬ ‫ﻣﻊ اﻻﺳﻒ اﻟﺸﺪﻳ ﺪ، ﻟﻦ ﻳﺘﻢ ﺗﻨﻔﻴﺬ اﳌﺸﻴ ﺪ '‬ ‫‪Dim Turki As Person‬‬ ‫ﺴﺘﻼﺤﻅ ﺍﻥ ‪ Visual Basic .NET‬ﻟﻡ ﻴﻘﻡ ﺒﺘﻨﻔﻴﺫ ﺫﻟﻙ ﺍﻟﻤﺸﻴﺩ، ﻭﺍﻟﺴﺒﺏ ﻗﺩ ﻴﺒـﺩﻭ ﺒـﺩﻴﻬﻴﺎ ﺍﻥ ﺘـﺫﻜﺭﺕ ﺍﻨـﻪ‬ ‫ﻴﻭﺠﺩ ﻤﺸﻴﺩ ‪ Sub New‬ﺍﺨﺭ )ﻟﻜﻨﻪ ﻤﺨﻔﻲ( ﺘﻡ ﺘﻨﻔﻴﺫﻩ ﺒﺩﻻ ﻤﻥ ﻤﺸﻴﺩﻨﺎ ﺍﻟﻅﺭﻴﻑ. ﻭﺤﺘﻰ ﻨﺒﻠـﻎ ﻤﺘـﺭﺠﻡ ﺍﻟﻠﻐـﺔ‬ ‫ﺍﻥ ﻋﻠﻴﻪ ﺘﻨﻔﻴﺫ ﻤﺸﻴﺩﻨﺎ ﺍﻟﺠﺩﻴﺩ، ﺒﺩﻻ ﻤﻥ ﺍﻟﻤﺸﻴﺩ ﺍﻟﻤﺨﻔﻲ ﻋﻠﻴﻨـﺎ ﺍﺴـﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤـﺔ ﺍﻟﻤﺤﺠـﻭﺯﺓ ‪ New‬ﻭﺍﺭﺴـﺎل‬ ‫ﹰ‬ ‫ﺍﻟﻭﺴﻴﻁﺎﺕ ﺍﻟﺘﻲ ﺘﻭﺍﻓﻕ ﺫﻟﻙ ﺍﻟﻤﺸﻴﺩ:‬ ‫ﺳﻴﺘﻢ ﺗﻨﻔ ﻴﺬ اﳌ ﺸﻴﺪ ﲟ ﺠﺮد ا ﻟﺘﺼﺮﻳ ﺢ ﻋﻦ اﳌﺘﻐﲑ هﻨ ﺎ '‬ ‫)"ﺗﺮآﻲ ا ﻟﻌﺴﲑ ي"(‪Dim Turki As New Person‬‬ ‫ﻟﻤﺎﺫﺍ؟ ﻜﻴﻑ؟ ﻭﻤﺎﻟﺴﺒﺏ؟ ﻜل ﻫﺫﻩ ﺍﻻﺴﺘﻔﺴﺎﺭﺍﺕ ﺴﺄﺘﻁﺭﻕ ﻟﻬﺎ ﻓﻲ ﺍﻟﻔﺼل ﺍﻟﺜﺎﻟﺙ ﺍﻟﻔﺌـﺎﺕ ﻭﺍﻟﻜﺎﺌﻨـﺎﺕ ﺒﻤﺸـﻴﺌﺔ‬ ‫ﺍﷲ، ﻟﺫﻟﻙ ﺍﻁﻠﺏ ﻤﻨﻙ ﻋﺯﻴﺯﻱ ﺍﻟﻘﺎﺭﺉ ﺍﻥ ﻻ ﺘﻘﻠﻕ ﻨﻔﺴﻙ ﻜﺜﻴﺭﺍ ﺒﺎﻻﺸﻴﺎﺀ ﺍﻟﻐﻴـﺭ ﻤﻔﻬﻭﻤـﻪ ﻫﻨـﺎ، ﺤﻴـﺙ ﺍﻨﻬـﺎ‬ ‫ﺘﺘﻌﻠﻕ ﺒﺎﻟﻜﺎﺌﻨﺎﺕ ﻭﻁﺭﻴﻘﺔ ﺍﻨﺸﺎﺌﻬﺎ، ﻭﻻ ﺍﻭﺩ ﻨﻘل ﻤﻭﺍﻀـﻴﻊ ﺍﻟﻔﺼـل ﺍﻟﺜﺎﻟـﺙ ﻫﻨـﺎ، ﻓـﻨﺤﻥ ﻤـﺎ ﺯﻟﻨـﺎ ﻨـﺘﻌﻠﻡ‬ ‫ﺍﻻﺴﺎﺴﻴﺎﺕ.‬
  • 82.
    ‫65‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻟﻨﻨﺘﻘل ﺍﻟﻰ ﻤﻭﻀﻭﻉ ﺍﺨﺭ ﻴﺘﻤﺤﻭﺭ ﺤﻭل ﻗﺎﺒﻠﻴﺔ ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﻋﻨﺎﺼﺭ ﺍﻟﺘﺭﻜﻴـﺏ، ﻓﺠﻤﻴـﻊ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ‬ ‫ﺍﻟﻤﺤﻀﻭﻨﺔ ﻓﻲ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﺍﻟﺴﺎﺒﻘﺔ ﻋﺭﻓﻨﺎﻫﺎ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ ،Dim‬ﻟـﺫﻟﻙ ﺘﻤﻜﻨـﺎ ﻤـﻥ ﺍﻟﻭﺼـﻭل‬ ‫ﺍﻟﻰ ﻋﻨﺎﺼﺭﻫﺎ. ﻭﻟﻜﻨﻙ ﻓﻲ ﺒﻌﺽ ﺍﻻﺤﻴﺎﻥ ﻗﺩ ﺘﻭﺩ ﺘﻌﺭﻴﻑ ﻤﺘﻐﻴﺭﺍﺕ ﻤﺨﻔﻴﺔ ﻻ ﻴﻤﻜﻥ ﺍﻟﻭﺼـﻭل ﺍﻟﻴﻬـﺎ ﺍﻻ ﻤـﻥ‬ ‫ﺩﺍﺨل ﺍﻟﺘﺭﻜﻴﺏ ﻨﻔﺴﻪ، ﻟﺫﻟﻙ ﻋﻠﻴﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Private‬ﺍﺜﻨـﺎﺀ ﺍﻟﺘﺼـﺭﻴﺢ ﻋـﻥ ﻤﺘﻐﻴـﺭ ﻓـﻲ‬ ‫ﺩﺍﺨل ﺍﻟﺘﺭﻜﻴﺏ:‬ ‫‪ Public‬ﻣﺜ ﻞ ‪ Dim‬هﻨﺎ '‬ ‫‪Structure Person‬‬ ‫‪Public Name As String‬‬ ‫‪Dim Age As Integer‬‬ ‫‪Private MotherName As String‬‬ ‫ﳝﻜﻦ اﻟﻮﺻ ﻮل اﱃ اﳌﺘﻐ ﲑ اﳌﺨ ﻔ ﻲ '‬ ‫ﻣﻦ داﺧﻞ اﻟﱰآﻴ ﺐ ﻓﻘ ﻂ '‬ ‫)(‪Sub Test‬‬ ‫"اﺣﻢ اﺣﻢ !" = ‪MotherName‬‬ ‫…‬ ‫…‬ ‫‪End Sub‬‬ ‫‪End Structure‬‬ ‫ﺍﻟﻜﻠﻤﺎﺕ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Public‬ﻭ ‪ Private‬ﻓﻲ ﺍﻟﺸـﻴﻔﺭﺓ ﺍﻟﺴـﺎﺒﻘﺔ، ﺘﺴـﻤﻰ ﻤﺤـﺩﺩﺍﺕ ﺍﻟﻭﺼـﻭل ‪Access‬‬ ‫‪ .Specifiers‬ﻴﻭﺠﺩ ﻨﻭﻉ ﺜﺎﻟﺙ ﻤﻥ ﻤﺤﺩﺩﺍﺕ ﺍﻟﻭﺼﻭل ﻴﺴﺘﺨﺩﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠـﻭﺯﺓ ‪ Friend‬ﻭﻅﻴﻔﺘـﻪ ﺘﻤﺎﺜـل‬ ‫ﻭﻅﻴﻔﺔ ﻤﺤﺩﺩ ﺍﻟﻭﺼﻭل ‪ ،Public‬ﺍﻻ ﺍﻥ ﻋﻨﺎﺼﺭ ﺍﻟﺘﺭﻜﻴﺏ ﻤﻥ ﻫﺫﺍ ﺍﻟﻨـﻭﻉ ﻻ ﻴﻤﻜـﻥ ﺍﻟﻭﺼـﻭل ﺍﻟﻴﻬـﺎ ﻤـﻥ‬ ‫ﺨﺎﺭﺝ ﺤﺩﻭﺩ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ )ﺍﻟﺫﻱ ﻋﺭﻑ ﻓﻴﻪ ﺍﻟﺘﺭﻜﻴﺏ(.‬ ‫ﻁﻭﻟﻨﺎﻫﺎ ﻭﻫﻲ ﻗﺼﻴﺭﺓ! ﺍﺨﺘﻡ ﻓﻘﺭﺓ ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ﻤﻥ ﻨﻭﻉ ‪ Structure‬ﺒﺘﻭﻀﻴﺢ ﻤـﺩﻯ ﻭ ﻗﺎﺒﻠﻴـﺔ ﺍﻟﺭﺅﻴـﺔ‬ ‫ﻟﻬﺎ ﻭﺍﻟﺘﻲ ﺘﻤﺎﺜل ﺍﻟﻤﺩﻯ ﻭ ﻗﺎﺒﻠﻴﺔ ﺍﻟﺭﺅﻴﺔ ﻟﻠﺘﺭﻜﻴﺒﺎﺕ ﻤـﻥ ﻨـﻭﻉ ‪ .Enum‬ﻭﺤﺘـﻰ ﺍﻏﻨﻴـﻙ ﻤـﻥ ﻋﻨـﺎﺀ ﻗﻠـﺏ‬ ‫ﺍﻟﺼﻔﺤﺎﺕ ﻟﻠﺒﺤﺙ ﻋﻨﻬﺎ، ﺩﻋﻨﻲ ﺍﻋﻴﺩ ﺼﻴﺎﻏﺘﻬﺎ ﻟﻙ ﻫﻨﺎ: ﺍﻥ ﻋﺭﻓﺕ ﺍﻟﺘﺭﻜﻴـﺏ ﺒﺎﺴـﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤـﺔ ﺍﻟﻤﺤﺠـﻭﺯﺓ‬ ‫‪ ،Private‬ﻓﺎﻥ ﻗﺎﺒﻠﻴﺔ ﺍﻟﺭﺅﻴﺔ ﻟﻬﺫﺍ ﺍﻟﺘﺭﻜﻴﺏ ﺴﺘﻜﻭﻥ ﻤﺤﺼﻭﺭﺓ ﺩﺍﺨل ﺍﻟﻭﺤﺩﺓ ﺍﻟﺒﺭﻤﺠﻴﺔ ﺍﻟﺫﻱ ﻋﺭﻑ ﻓﻴﻬـﺎ ﻫـﺫﺍ‬ ‫ﺍﻟﺘﺭﻜﻴﺏ، ﺍﻤﺎ ﺍﻥ ﺍﺴﺘﺨﺩﻤﺕ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪) Public‬ﺍﻭ ﺤﺘﻰ ﺘﺠﺎﻫﻠﺘﻬﺎ( ﻓﺴﺘﻜﻭﻥ ﻗﺎﺒﻠﻴـﺔ ﺍﻟﺭﺅﻴـﺔ ﺸـﺎﻤﻠﺔ‬ ‫ﻟﺒﺎﻗﻲ ﻤﻠﻔﺎﺕ ﺍﻟﻤﺸﺭﻭﻉ. ﻤﻊ ﺍﻟﻌﻠﻡ ﺍﻨﻙ ﺘﺴﺘﻁﻴﻊ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Friend‬ﺍﻴﻀﺎ.‬ ‫اﻟﻤﺼﻔﻮﻓﺎت‬ ‫ﻴﻤﻜﻨﻙ ‪ Visual Basic .NET‬ﻤﻥ ﺘﻌﺭﻴﻑ ﺍﻟﻤﺼﻔﻭﻓﺎﺕ ﺴﻭﺍﺀ ﻜﺎﻨﺕ ﺍﺤﺎﺩﻴﺔ ﺍﻟﺒﻌﺩ ﺍﻭ ﻤﺘﻌﺩﺩﺓ ﺍﻻﺒﻌﺎﺩ ﻭﺍﻟﺘـﻲ‬ ‫ﻗﺩ ﺘﺼل ﺍﻟﻰ 23 ﺒﻌﺩﺍ:‬ ‫01 ﻋﻨﺎﺻ ﺮ '‬ ‫2 * 2 = 4 ﻋﻨﺎ ﺻ ﺮ '‬ ‫‪Dim OneDim (9) As Integer‬‬ ‫‪Dim TwoDims (1, 1) As String‬‬ ‫ﻴﻤﻜﻨﻙ ﻓﻭﺭﺍ ﺍﻟﺒﺩﺀ ﺒﻌﻤﻠﻴﺔ ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ ﻟﻬﺎ –ﻜﻤﺎ ﺘﻔﻌل ﻤﻊ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﺩﻴـﺔ - ﻤـﻊ ﺍﻟﻌﻠـﻡ ﺍﻥ ﺒـﺩﺀ ﺍﻟﺘـﺭﻗﻴﻡ‬ ‫ﻟﻔﻬﺭﺱ ﺍﻟﻤﺼﻔﻭﻓﺎﺕ ﻴﺒﺩﺃ ﺒﺎﻟﺭﻗﻡ 0:‬
  • 83.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫75‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫001 = )0( ‪OneDim‬‬ ‫002 = )1( ‪OneDim‬‬ ‫…‬ ‫009 = )9( ‪OneDim‬‬ ‫"ﺗﺮآ ﻲ"‬ ‫"اﻟﻌﺴ ﲑ ي"‬ ‫"ﻋﺒﺎ س"‬ ‫"اﻟﺴﺮ ﻳ ﻊ"‬ ‫=‬ ‫=‬ ‫=‬ ‫=‬ ‫)0‬ ‫)1‬ ‫)0‬ ‫)1‬ ‫,0(‬ ‫,0(‬ ‫,1(‬ ‫,1(‬ ‫‪TwoDims‬‬ ‫‪TwoDims‬‬ ‫‪TwoDims‬‬ ‫‪TwoDims‬‬ ‫ﻭﺍﻥ ﻜﻨﺕ ﻤﺴﺘﻌﺠﻼ ﻓﻲ ﻋﻤﻠﻴﺔ ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ، ﻓﺈﻥ ﻫﺫﺍ ﻤﺘﺎﺡ ﻟﻙ ﻓﻲ ﺴﻁﺭ ﺍﻟﺘﺼﺭﻴﺢ ﻤﺒﺎﺸـﺭ ﹰ، ﺸـﺭﻴﻁﺔ‬ ‫ﺓ‬ ‫ﹰ‬ ‫ﻋﺩﻡ ﺘﺤﺩﻴﺩ ﻋﺩﺩ ﻋﻨﺎﺼﺭ ﺍﻟﻤﺼﻔﻭﻓﺔ:‬ ‫}9 ,8 ,7 ,6 ,5 ,4 ,3 ,2 ,1{ = ‪Dim OneDim() As Integer‬‬ ‫}}"اﻟﺴﺮﻳ ﻊ" ,"ﻋﺒﺎ س"{ ,}"اﻟﻌﺴﲑ ي" ,"ﺗﺮآ ﻲ"{{ = ‪Dim TwoDims(,) As String‬‬ ‫ﺍﻟﻤﺼﻔﻭﻓﺎﺕ ﺍﻟﺴﺎﺒﻘﺔ ﺘﺴﻤﻰ ﻤﺼـﻔﻭﻓﺎﺕ ﺩﻴﻨﺎﻤﻴﻜﻴـﺔ ‪ Dynamics Arrays‬ﻻﻨﻨـﺎ ﻟـﻡ ﻨﺤـﺩﺩ ﻋـﺩﺩ‬ ‫ﻋﻨﺎﺼﺭﻫﺎ، ﺍﻟﻤﻴﺯﺓ ﻓﻲ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺼﻔﻭﻓﺎﺕ ﻫﻭ ﺍﻤﻜﺎﻨﻴﺔ ﺘﻐﻴﻴﺭ ﺤﺠﻤﻬـﺎ ﻤـﻥ ﻭﻗـﺕ ﻻﺨـﺭ ﺒﺎﺴـﺘﺨﺩﺍﻡ‬ ‫‪ ،ReDim‬ﻤﻊ ﺍﻻﺸﺎﺭﺓ ﺇﻟﻰ ﺍﻥ ﻋﻨﺎﺼﺭ ﺍﻟﻤﺼﻔﻭﻓﺔ ﺍﻟﻤﻌﺎﺩ ﺘﻐﻴﻴﺭ ﺤﺠﻤﻬﺎ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪ ReDim‬ﺴﻭﻑ ﺘﻠﻐﻰ:‬ ‫)99( ‪ReDim OneDim‬‬ ‫)01 ,01( ‪ReDim TwoDims‬‬ ‫0 ' ) )0(‪ArabicConsole.WriteLine ( OneDim‬‬ ‫ﻤﻊ ﺫﻟﻙ، ﻴﻤﻜﻨﻙ ﺘﻐﻴﻴﺭ ﺤﺠﻡ ﺍﻟﻤﺼﻔﻭﻓﺔ ﺩﻭﻥ ﺍﻟﻤﺨﺎﻁﺭﺓ ﺒﻔﻘﺩ ﺒﻴﺎﻨﺎﺘﻬـﺎ ﺒﺎﺴـﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤـﺔ ﺍﻟﻤﺤﺠـﻭﺯﺓ‬ ‫‪ ،Preserve‬ﻭﻟﻜﻥ –ﻤﻊ ﺍﻻﺴﻑ ﺍﻟﺸﺩﻴﺩ - ﻻ ﻴﻤﻜﻥ ﺘﻐﻴﻴﺭ ﺍﻻ ﻋﺩﺩ ﻋﻨﺎﺼﺭ ﺍﻟﺒﻌـﺩ ﺍﻻﺨﻴـﺭ ﻓﻘـﻁ ﻓـﻲ ﻫـﺫﻩ‬ ‫ﺍﻟﺤﺎﻟﺔ:‬ ‫ﳑﻜﻦ ﺟﺪ ا '‬ ‫)005( ‪ReDim Preserve OneDim‬‬ ‫)005 ,01( ‪ReDim Preserve TwoDims‬‬ ‫رﺳﺎﻟﺔ ﺧﻄ ﺄ '‬ ‫)005 ,005( ‪ReDim Preserve TwoDims‬‬ ‫ﻭﻤﻊ ﺍﻻﺴﻑ ﺍﻟﺸﺩﻴﺩ ﺍﻴﻀﺎ، ﻻ ﻴﻤﻜﻨﻙ ﺘﻐﻴﻴﺭ ﻋﺩﺩ ﺍﺒﻌﺎﺩ ﺍﻟﻤﺼﻔﻭﻓﺔ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴـﺔ ﺴـﻭﺍﺀ ﺍﺴـﺘﺨﺩﻤﺕ ‪Preserve‬‬ ‫ﺍﻭ ﻟﻡ ﺘﺴﺘﺨﺩﻤﻬﺎ:‬ ‫رﺳﺎﻟﺔ ﺧﻄ ﺄ '‬ ‫)005 ,005( ‪ReDim Preserve OneDim‬‬ ‫)001( ‪ReDim TwoDims‬‬ ‫ﻓﻲ ﺍﻟﻤﻘﺎﺒل، ﺘﺴﺘﻁﻴﻊ ﺘﺩﻤﻴﺭ ﺍﻟﻤﺼﻔﻭﻓﺔ ﺍﻟﺩﻴﻨﺎﻤﻴﻜﻴﺔ ﻟﺘﺤﺭﻴﺭ ﺍﻟﻤﺴـﺎﺤﺔ ﻓـﻲ ﺍﻟـﺫﺍﻜﺭﺓ ﻓـﻲ ﺍﻱ ﻭﻗـﺕ ﺘﺭﻴـﺩﻩ‬ ‫ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻻﻤﺭ ‪:Erase‬‬ ‫‪Erase OneDim‬‬ ‫‪Erase TwoDims‬‬
  • 84.
    ‫85‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻋﻠﻰ ﺼﻌﻴﺩ ﺍﺨﺭ، ﺍﻟﻤﺼﻔﻭﻓﺎﺕ ﺘﻌﺘﺒﺭ ﻤﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﺭﺠﻌﻴﺔ ‪ Reference Type‬ﻓـﻼ ﻴﻤﻜﻨـﻙ ﻨﺴـﺦ‬ ‫ﻗﻴﻤﻬﺎ ﺒﺎﺴﺘﺨﺩﺍﻡ ﻤﻌﺎﻤل ﺍﺴﻨﺎﺩ ﺍﻟﻘﻴﻡ "=". ﻟﻲ ﻋﻭﺩﺓ ﺤﻭل ﺍﻟﻤﺼﻔﻭﻓﺎﺕ ﻓﻲ ﺍﻟﻔﺼل ﺍﻟﺴﺎﺩﺱ ﺍﻟﻔﺌـﺎﺕ ﺍﻻﺴﺎﺴـﻴﺔ،‬ ‫ﺍﻤﺎ ﺍﻻﻥ ﺩﻋﻨﻲ ﺍﻋﺭﺽ ﻟﻙ ﻜﻴﻑ ﻨﻨﺴﺦ ﻗﻴﻤﺔ ﻤﺼﻔﻭﻓﺔ ﺍﻟﻰ ﺍﺨﺭﻯ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻁﺭﻴﻘﺔ )(‪:Clone‬‬ ‫}… ,3 ,2 ,1{ = ‪Dim X () As Integer‬‬ ‫‪Dim Y () As Integer‬‬ ‫ﻧﺴﺦ اﳌﺼﻔﻮ ﻓﺔ ‪ X‬ا ﱃ ‪' Y‬‬ ‫)(‪Y = X.Clone‬‬ ‫ﺍﻨﻬﻲ ﺤﺩﻴﺜﻲ ﻋﻥ ﺍﻟﻤﺼﻔﻭﻓﺎﺕ ﺒﺫﻜﺭ ﺍﻟﺩﺍﻟﺔ )(‪ UBound‬ﺍﻟﺘﻲ ﺘﻌﻭﺩ ﺒﺭﻗﻡ ﻓﻬـﺭﺱ ﺍﻟﻌﻨﺼـﺭ ﺍﻻﺨﻴـﺭ‬ ‫ﻟﻠﻤﺼﻔﻭﻓﺔ، ﻭﺍﻟﺩﺍﻟﺔ )(‪ LBound‬ﺒﺭﻗﻡ ﺍﻟﻔﻬﺭﺱ ﻟﻠﻌﻨﺼﺭ ﺍﻻﻭل:‬ ‫)‪For counter = LBound(OneDim) To UBound(OneDim‬‬ ‫…‬ ‫…‬ ‫‪Next‬‬ ‫ﻭﺒﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﺼﻔﻭﻓﺎﺕ ﺍﻟﻤﺘﻌﺩﺩﺓ ﺍﻻﺒﻌﺎﺩ، ﻴﺘﻭﺠﺏ ﻋﻠﻴﻙ ﺍﺭﺴﺎل ﺭﻗﻡ ﺍﻟﺒﻌﺩ ﺍﻟﺫﻱ ﺘﻭﺩ ﻤﻌﺭﻓﺔ ﻓﻬﺭﺴﺘﻪ:‬ ‫اﻟﺒﻌ ﺪ اﻻو ل '‬ ‫اﻟﺒﻌ ﺪ اﻻو ل '‬ ‫اﻟﺒﻌ ﺪ اﻟﺜ ﺎﻧ ﻲ '‬ ‫)‪UBound(OneDim‬‬ ‫)1 ,‪UBound(OneDim‬‬ ‫)2 ,‪UBound(OneDim‬‬ ‫اﻻﺟﺮاءات واﻟﺪوال‬ ‫ﻴﻤﻜﻨﻙ ‪ Visual Basic .NET‬ﻤﻥ ﺘﻌﺭﻴﻑ ﺍﻻﺠﺭﺍﺀﺍﺕ ﺍﻤـﺎ ﺒﺎﻟﻜﻠﻤـﺔ ﺍﻟﻤﺤﺠـﻭﺯﺓ ‪ Sub‬ﺍﻭ ‪،Function‬‬ ‫ﺤﻴﺙ ﺍﻥ ﺍﺴﺘﺨﺩﺍﻤﻙ ﻟﻠﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ﺍﻟﺜﺎﻨﻴﺔ ﻴﺠﻌل ﺍﻻﺠﺭﺍﺀ ﻗﺎﺩﺭﺍ ﻋﻠﻰ ﺍﻟﻌﻭﺩﺓ ﺒﻘﻴﻤـﺔ ﻨﻭﻋﻬـﺎ ﺘﺤـﺩﺩﻩ ﻋﻨـﺩ‬ ‫ﺘﻌﺭﻴﻑ ﺍﻻﺠﺭﺍﺀ:‬ ‫اﺟﺮاء ﻻ ﻳﻌﻮد ﺑﻘﻴﻤ ﺔ '‬ ‫)(‪Sub MySub‬‬ ‫)"اﺟﺮاء ﻻ ﻳﻌﻮ د ﺑﻘﻴ ﻤ ﺔ"( ‪ArabicConsole.WriteLine‬‬ ‫‪End Sub‬‬ ‫داﻟﺔ ﺗﻌﻮ د ﺑﻘﻴ ﻤﺔ ﻣ ﻦ '‬ ‫اﻟﻨﻮ ع ‪' Long‬‬ ‫‪Function Abs (ByVal X As Integer) As Long‬‬ ‫‪If X < 0 Then‬‬ ‫‪Return -X‬‬ ‫‪Else‬‬ ‫‪Return X‬‬ ‫‪End If‬‬ ‫‪End Function‬‬
  • 85.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫95‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻋﻨﺩ ﺍﺴﺘﺩﻋﺎﺀ ﺍﻻﺠﺭﺍﺀﺍﺕ، ﻋﻠﻴﻙ ﻜﺘﺎﺒﺔ ﺍﻻ ﻗﻭﺍﺱ ﺤﺘﻰ ﻟﻭ ﻟﻡ ﺘﻭﺠﺩ ﻭﺴﻴﻁﺎﺕ ‪ Parameters‬ﺘﺭﺴﻠﻬﺎ ﻟﻬﺎ:‬ ‫ﺳﻴﻘﻮم اﶈ ﺮر ﺑﺎ ﺿﺎﻓﺔ اﻻﻗﻮا س ان ﱂ ﺗﻀﻔ ﻬ ﺎ '‬ ‫)( ‪MySub‬‬ ‫5 ' ))5-( ‪ArabicConsole.WriteLine (Abs‬‬ ‫ﺘﺴﺘﻁﻴﻊ ﺍﻨﻬﺎﺀ ﺍﻻﺠﺭﺍﺀ ﻓﻲ ﺍﻱ ﻭﻗﺕ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻻﻤﺭ ‪ Exit Sub‬ﺍﻥ ﺘﻡ ﺍﻟﺘﻌﺭﻴـﻑ ﺒﺎﺴـﺘﺨﺩﺍﻡ ‪ Sub‬ﺍﻭ‬ ‫‪ Exit Function‬ﺍﻥ ﺘﻡ ﺍﻟﺘﻌﺭﻴﻑ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪:Function‬‬ ‫‪Function Abs (ByVal X As Integer) As Long‬‬ ‫‪If X = 0 Then‬‬ ‫‪Exit Function‬‬ ‫‪End If‬‬ ‫…‬ ‫…‬ ‫‪End Function‬‬ ‫ﻣﻼﺣﻈﺔ‬ ‫ان اﺳـﺘﺨﺪﻣﺖ اﻻﻣـﺮ ‪ Exit Function‬دون ﺗﻌﻴـﻴﻦ ﻗﻴﻤـﺔ ﻟﻠﺪاﻟـﺔ، ﻓﺴـﺘﻌﻮد‬ ‫اﻟﺪاﻟﺔ ﺑﻘﻴﻤﺔ 0 ان آﺎﻧﺖ ﻋﺪدﻳﺔ، ﻻﺷـﺊ ان آﺎﻧـﺖ ﺣﺮﻓ ﻴـﺔ، او ‪ Nothing‬ان‬ ‫آﺎﻧﺖ آﺎﺋﻨﻴﺔ..‬ ‫ﻭﺒﺎﻟﻨﺴﺒﺔ ﻟﻘﺎﺒﻠﻴﺔ ﺍﻟﺭﺅﻴﺔ ﻓﻬﻲ ﺍﻤﺎ ﺘﻜﻭﻥ ‪ ،Private‬ﺍﻭ ‪ ،Friend‬ﺍﻭ ‪ Public‬ﻜﺎﻟﻤﺘﻐﻴﺭﺍﺕ.‬ ‫اﻻرﺳﺎل ﺑﺎﻟﻤﺮﺟﻊ او اﻟﻘﻴﻤﺔ‬ ‫ﺒﺸﻜل ﺍﻓﺘﺭﺍﻀﻲ، ﺍﻟﻭﺴﻴﻁﺎﺕ ﺍﻟﺘﻲ ﻴﺴﺘﻘﺒﻠﻬﺎ ﺍﻻﺠـﺭﺍﺀ ﻫـﻲ ﻤﺘﻐﻴـﺭﺍﺕ ﺍﺭﺴـﻠﺕ ﺒﺎﻟﻘﻴﻤـﺔ، ﻭﺍﻥ ﺍﺭﺩﺕ ﻤـﻥ‬ ‫ﺍﺠﺭﺍﺀﺍﺘﻙ ﺍﻥ ﺘﺴﺘﻘﺒل ﻗﻴﻤﻬﺎ ﺒﺎﻟﻤﺭﺠﻊ ﺤﻴﺙ ﻴﻤﻜﻨـﻙ ﺘﻌـﺩﻴل ﻗـﻴﻡ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺍﻟﻤﺭﺴـﻠﺔ، ﺍﺴـﺘﺨﺩﻡ ﺍﻟﻜﻠﻤـﺔ‬ ‫ﺍﻟﻤﺤﺠﻭﺯﺓ ‪:ByRef‬‬ ‫هﻨﺎ ﺑﺎﻟﻘ ﻴﻤﺔ و ﻟﻦ ﺗﺘ ﺄﺛﺮ ا ﳌﺘﻐﲑا ت اﳌﺮ ﺳﻠ ﺔ '‬ ‫)‪Sub swapByVal(ByVal a As Integer, ByVal b As Integer‬‬ ‫‪Dim temp As Integer‬‬ ‫‪temp = a‬‬ ‫‪a = b‬‬ ‫‪b = temp‬‬ ‫‪End Sub‬‬ ‫اﻣﺎ هﻨﺎ ﺑﺎﳌﺮﺟ ﻊ وﺳﺘ ﺘﺄﺛﺮ اﳌﺘﻐﲑ ات اﳌ ﺮﺳﻠ ﺔ '‬ ‫)‪Sub swapByRef(ByRef a As Integer, ByRef b As Integer‬‬ ‫‪Dim temp As Integer‬‬ ‫‪temp = a‬‬ ‫‪a = b‬‬ ‫‪b = temp‬‬ ‫‪End Sub‬‬
  • 86.
    ‫06‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻴﺘﻀﺢ ﺍﻟﻔﺭﻕ ﻓﻲ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ:‬ ‫‪Dim A As Integer‬‬ ‫‪Dim B As Integer‬‬ ‫01 = ‪A‬‬ ‫02 = ‪B‬‬ ‫ارﺳﺎل ﺑﺎ ﻟﻘﻴﻤ ﺔ '‬ ‫)‪swapByVal (A, B‬‬ ‫01 ' )‪ArabicConsole.WriteLine (A‬‬ ‫02 ' )‪ArabicConsole.WriteLine (B‬‬ ‫ارﺳﺎل ﺑﺎ ﳌﺮﺟ ﻊ '‬ ‫)‪swapByRef (A, B‬‬ ‫02 ' )‪ArabicConsole.WriteLine (A‬‬ ‫01 ' )‪ArabicConsole.WriteLine (B‬‬ ‫ﻭﻟﻠﺤﺩﻴﺙ ﻋﻥ ﺍﻟﻤﺴﺎﺌل ﺍﻟﺘﻘﻨﻴﺔ، ﺴﺄﺒﺩﺍ ﺒﻌﻤﻠﻴﺔ ﺍﺭﺴﺎل ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺒﺎﻟﻘﻴﻤـﺔ، ﻓﻬـﻲ ﺍﺒﻁـﺄ ﻤـﻥ ﺍﻻﺭﺴـﺎل‬ ‫ﺒﺎﻟﻤﺭﺠﻊ ﻭﺫﻟﻙ ﻻﻨﻪ ﺴﻴﺘﻡ ﺍﻨﺸﺎﺀ ﻨﺴﺨﺔ ﻤﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﺭﺴﻠﺔ ﻓﻲ ﻜل ﻤـﺭﺓ ﺘﺴـﺘﺩﻋﻲ ﺍﻻﺠـﺭﺍﺀ. ﻤـﻥ ﻨﺎﺤﻴـﺔ‬ ‫ﺍﺨﺭﻯ، ﺘﻭﺠﺩ ﻤﻴﺯﺓ ﻓﻲ ﻋﻤﻠﻴﺔ ﺍﺭﺴﺎل ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺒﺎﻟﻘﻴﻤﺔ، ﻭﻫﻲ ﻋﺩﻡ ﺍﻟﺘﺄﺜﻴﺭ ﻋﻠﻰ ﺒﺎﻗﻲ ﺍﺠـﺯﺍﺀ ﺍﻟﺒﺭﻨـﺎﻤﺞ ﺍﻥ‬ ‫ﻗﻤﺕ ﺒﺘﻌﺩﻴل ﻗﻴﻤﻬﺎ ﺒﻁﺭﻴﻕ ﺍﻟﺨﻁﺄ. ﺍﻤﺎ ﺍﻻﺭﺴﺎل ﺒﺎﻟﻤﺭﺠﻊ، –ﻜﻤﺎ ﻗﻠﺕ ﻗﺒل ﻗﻠﻴل - ﻫﻭ ﺍﺴـﺭﻉ ﻤـﻥ ﺍﻻﺭﺴـﺎل‬ ‫ﺒﺎﻟﻘﻴﻤﺔ، ﻓﺎﻨﺕ ﺘﺭﺴل ﻤﺅﺸﺭ ﻟﻠﻤﺘﻐﻴﺭ ﻤﻤﺎ ﻴﻤﻜﻨﻙ ﻤﻥ ﺘﻌﺩﻴل ﻗﻴﻤﺔ ﺍﻟﻤﺘﻐﻴﺭ ﺍﻟﻤﺭﺴل.‬ ‫ﻣﻼﺣﻈﺔ‬ ‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﺘﻐﻴﺮات اﻟﻤﺮﺟﻌﻴﺔ ‪ Reference Ty pe Variables‬اﻟﻤﺮﺳﻠﺔ اﻟﻰ‬ ‫اﻻﺟﺮاءات، ﺳﺘﺘﺄﺛﺮ ﺑﺎﻟﺘﻐﻴﻴﺮات ﺣﺘﻰ وان ارﺳـﻠﺖ ﺑﺎﻟﻘﻴﻤـﺔ، اي ﺑﺎﺳـﺘﺨﺪام‬ ‫اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪.By Val‬‬ ‫ﺗﺨﺼﻴﺺ اﻟﻮﺳﻴﻄﺎت اﻟﻤﺮﺳﻠﺔ‬ ‫ﺍﻟﻤﺯﻴﺩ ﻤﻥ ﺍﻟﺘﺨﺼﻴﺹ ﺤﻭل ﺍﻟﻭﺴﻴﻁﺎﺕ ﻴﻭﻓﺭﻩ ﻟﻙ ‪ ،Visual Basic .NET‬ﺍﺫ ﻴﻤﻜﻨﻙ ﻤﻥ ﺍﻟﺘﺼـﺭﻴﺢ ﻋـﻥ‬ ‫ﺍﻟﻭﺴﻴﻁﺎﺕ ﺍﻻﺨﺘﻴﺎﺭﻴﺔ ‪ Optional‬ﻭﺍﻟﻐﻴﺭ ﻤﺤﺩﻭﺩﺓ ﺍﻟﻌﺩﺩ ‪.ParamArray‬‬ ‫ﺍﻟﻭﺴﻴﻁﺎﺕ ﺍﻻﺨﺘﻴﺎﺭﻴﺔ:‬ ‫ﺍﺤﻴﺎﻨﺎ ﺘﻭﺩ ﻤﻥ ﺍﺠﺭﺍﺀﺍﺘﻙ ﺍﻥ ﺘﻜﻭﻥ ﻤﺭﻨﺔ ﺒﻤﺎ ﻓﻴﻪ ﺍﻟﻜﻔﺎﻴﺔ ﺒﺤﺙ ﻻ ﺘﺸﺘﺭﻁ ﺘﻭﺍﻓﻕ ﻋـﺩﺩ ﺍﻟﻤﺘﻐﻴـﺭﺍﺕ ﺍﻟﻤﺭﺴـﻠﺔ‬ ‫ﻤﻊ ﻋﺩﺩ ﻭﺴﻴﻁﺎﺕ ﺍﻻﺠﺭﺍﺀ، ﺘﺴﺘﻁﻴﻊ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ Optional‬ﻗﺒل ﻜل ﻭﺴﻴﻁﺔ ﺍﺨﺘﻴﺎﺭﻴـﺔ ﻤـﻊ‬ ‫ﻀﺭﻭﺭﺓ ﺘﺤﺩﻴﺩ ﻗﻴﻤﺔ ﺍﻓﺘﺭﺍﻀﻴﺔ ﻟﻬﺎ ﻓﻲ ﺤﺎﻟﺔ ﻋﺩﻡ ﺍﺭﺴﺎل ﻗﻴﻤﺔ ﻟﻼﺠﺭﺍﺀ:‬
  • 87.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫16‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫)1- = ‪Sub MySub(Optional ByVal X As Integer‬‬ ‫‪If X = -1 Then‬‬ ‫)"ﱂ ﺗﺮﺳ ﻞ ﻗﻴﻤ ﺔ"( ‪ArabicConsole.WriteLine‬‬ ‫‪End If‬‬ ‫…‬ ‫…‬ ‫‪End Sub‬‬ ‫ﻨﻘﻁﺔ ﺍﺨﺭﻯ، ﻻ ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠـﻭﺯﺓ ‪ Optional‬ﺍﻻ ﻓـﻲ ﺍﻟﻭﺴـﻴﻁﺎﺕ ﺍﻻﺨﻴـﺭﺓ )ﺍﻱ‬ ‫ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺠﻬﺔ ﺍﻟﻴﻤﻴﻥ( ﻓﻼ ﻴﻤﻜﻥ ﻟﻭﺴﻴﻁﺔ ﺍﺨﺘﻴﺎﺭﻴﺔ ﺍﻥ ﺘﺴﺒﻕ ﻭﺴﻴﻁﺔ ﻋﺎﺩﻴﺔ:‬ ‫هﻜﺬا ﳑﻜ ﻦ '‬ ‫)1- = ‪Sub MySub(ByVal Y As Byte, Optional ByVal X As Integer‬‬ ‫…‬ ‫…‬ ‫‪End Sub‬‬ ‫اﻧﺴﻰ هﺬﻩ اﻟﻔﻜ ﺮ ة '‬ ‫)‪Sub MySub(Optional ByVal X As Integer = -1, ByVal Y As Byte‬‬ ‫…‬ ‫…‬ ‫‪End Sub‬‬ ‫ﺍﻟﻭﺴﻴﻁﺎﺕ ﻏﻴﺭ ﻤﺤﺩﻭﺩﺓ ﺍﻟﻌﺩﺩ:‬ ‫ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﻓﺎﻨﻙ ﻻ ﺘﺤﺩﺩ ﻋﺩﺩﺍ ﻤﻌﻴﻨﺎ ﻟﻠﻭﺴﻴﻁﺎﺕ ﺍﻟﺘﻲ ﻴﺴﺘﻘﺒﻠﻬﺎ ﺍﻻﺠﺭﺍﺀ، ﻻﻥ ﺍﻟﻘﻴﻡ ﺴﺘﺭﺴـل ﻭﺘﺤﻔـﻅ ﻓـﻲ‬ ‫ﻤﺼﻔﻭﻓﺔ ﺘﻌﺭﻓﻬﺎ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪:ParamArray‬‬ ‫‪Function Sum(ByVal ParamArray Nums() As Integer) As Integer‬‬ ‫‪Dim counter As Integer‬‬ ‫)‪For counter = 0 To UBound(Nums‬‬ ‫)‪Sum += Nums(counter‬‬ ‫‪Next‬‬ ‫‪End Function‬‬ ‫ﺘﻁﺒﻴ ﻘﻴﺎ، ﻜل ﻫﺫﻩ ﺍﻻﺴﺘﺩﻋﺎﺀﺍﺕ ﺼﺤﻴﺤﺔ ﺒﺎﺴﺘﺜﻨﺎﺀ ﺍﻻﺨﻴﺭﺓ ﺍﻟﺫﻱ ﻴﺘﻭﻗﻊ ﺍﻨﻪ ﺍﺨﺘﻴﺎﺭﻱ:‬ ‫1 '‬ ‫4 '‬ ‫51 '‬ ‫) )1( ‪ArabicConsole.WriteLine ( Sum‬‬ ‫) )2 ,2( ‪ArabicConsole.WriteLine ( Sum‬‬ ‫) )5 ,4 ,3 ,2 ,1( ‪ArabicConsole.WriteLine ( Sum‬‬ ‫ﺧﻄﺄ هﻨ ﺎ '‬ ‫) )3 , ,1( ‪ArabicConsole.WriteLine ( Sum‬‬ ‫ﺗﺠﺎوز اﻟﺤﺪود ﻣﻊ ‪Windows API‬‬ ‫ﺍﻥ ﻜﻨﺕ ﻻ ﺘﻌﺭﻑ ﻤﺎ ﻫﻲ ﺍﺠﺭﺍﺀﺍﺕ ‪ ،Windows API‬ﻓﺎﻋﺘﺒﺭ ﻨﻔﺴﻙ ﻤﺒﺭﻤﺞ ﻤﺤﻅﻭﻅ ﺠـﺩﺍ! ﻭﺒﻤـﺎ ﺍﻨﻨـﻲ‬ ‫ﻟﺴﺕ ﻤﻥ ﺍﻟﻤﺒﺭﻤﺠﻴﻥ ﺍﻟﺸﺠﻌﺎﻥ، ﻓﻠﻥ ﺍﺘﺤﺩﺙ ﻋﻨﻬﺎ. ﺍﻤﺎ ﺍﻥ ﻜﻨﺕ ﻤـﻥ ﻤﺒﺭﻤﺠـﻲ ‪ Windows‬ﺍﻟﻤﺨﻀـﺭﻤﻴﻥ،‬ ‫ﻓﺘﺴﺘﻁﻴﻊ ﺍﻟﺘﺼﺭﻴﺢ ﻋـﻥ ﺍﺠـﺭﺍﺀﺍﺕ ‪ Windows API‬ﻟﻠﺘﺠـﺎﻭﺯ ﺤـﺩﻭﺩ ﻋـﺎﻟﻡ ﺍﻁـﺎﺭ ﻋﻤـل ‪.NET‬‬ ‫‪ .Framework‬ﻟﻌﻤل ﺫﻟﻙ، ﺼﺭﺡ ﻋﻥ ﺍﻻﺠﺭﺍﺀ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠـﻭﺯﺓ ‪ Declare‬ﻤـﻊ ﺘﺤﺩﻴـﺩ ﻨـﻭﻉ‬
  • 88.
    ‫26‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺼﻔﺤﺔ ﺍﻟﻤﺤﺎﺭﻑ ﺍﻤﺎ ‪ ،Unicode ،Ansi‬ﺍﻭ ‪ .Auto‬ﺍﻥ ﺍﺴﺘﺨﺩﻤﺕ ‪ ،Auto‬ﺴﻴﺘﻡ ﺘﺤﻭﻴـل ﺍﻟﺤـﺭﻭﻑ ﺍﻟـﻰ‬ ‫‪ Unicode‬ﺘﺤﺕ ﺠﻤﻴﻊ ﺍﻻﻨﻅﻤﺔ ﺒﺎﺴـﺘﺜﻨﺎﺀ 89 ‪ Windows‬ﻭ ‪ Windows ME‬ﺤﻴـﺙ ﺴـﺘﺘﺤﻭل ﺍﻟـﻰ‬ ‫‪:Ansi‬‬ ‫1‪Module Module‬‬ ‫_ ‪Declare Auto Function GetUserName Lib "advapi32.dll" Alias‬‬ ‫_ ,‪"GetUserNameA" (ByVal lpBuffer As String‬‬ ‫‪ByRef nSize As Integer) As Integer‬‬ ‫)( ‪Sub Main‬‬ ‫…‬ ‫…‬ ‫)‪GetUserName (x, y‬‬ ‫‪End Sub‬‬ ‫‪End Module‬‬ ‫اﻟﺘﻔﺮع واﻟﺘﻜﺮار‬ ‫ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺎﺕ ﻤﻥ ﺍﻟﺼﻌﺏ ﺘﻁﺒﻴﻘﻬﺎ ﺒﺭﻤﺠﻴﺎ ﺩﻭﻥ ﺍﺴﺘﺨﺩﺍﻤﻙ ﻟﺠﻤل ﺍﻟﺘﻔﺭﻉ ﻭﺤﻠﻘﺎﺕ ﺍﻟﺘﻜﺭﺍﺭ. ﻓﻲ ﻫـﺫﺍ ﺍﻟﻘﺴـﻡ‬ ‫ﻤﻥ ﺍﻟﻔﺼل ﺴﻨﺘﻭﻏل ﻓﻲ ﻋﺒﺎﺭﺍﺕ ﺍﻟﺘﻔﺭﻉ ‪ If … Then‬ﻭ ‪ ،Select Case‬ﻜﻤﺎ ﺴـﺄﺘﻁﺭﻕ ﺍﻟـﻰ ﺍﻟﺤﻠﻘـﺎﺕ‬ ‫ﺍﻟﺘﻜﺭﺍﺭﻴﺔ ﺍﻟﻤﺨﺘﻠﻔﺔ ﺍﻟﻤﺘﻭﻓﺭﺓ ﻓﻲ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ‪.Visual Basic .NET‬‬ ‫اﻟﺘﻔﺮع ﺑﺎﺳﺘﺨﺪام ‪If … Then‬‬ ‫ﺍﺴﺘﺨﺩﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ If‬ﻟﺘﻀﻴﻑ ﺍﻟﻴﻬﺎ ﺠﻤﻠﺔ ﺸﺭﻁﻴﺔ ﺜـﻡ ﺘﻠﺤﻘﻬـﺎ ﺒﻜﻠﻤـﺔ ‪ ،Then‬ﻭﻻ ﺘﻨﺴـﻰ ﺍﺴـﺘﺨﺩﺍﻡ‬ ‫‪ End If‬ﺍﻥ ﻭﺯﻋﺕ ﺍﻭﺍﻤﺭ ﺍﻟﺸﺭﻁ ﻓﻲ ﺍﻜﺜﺭ ﻤﻥ ﺴﻁﺭ )ﻭﻫﻭ ﺍﻟﻤﻔﻀل(:‬ ‫ﰲ ﺳﻄﺮ وا ﺣ ﺪ '‬ ‫1 = ‪If X = 0 Then Y‬‬ ‫4 = ‪If X = 1 Then X = 2 : Y‬‬ ‫2 = ‪If Y = 1 Then X = 0 Else X‬‬ ‫ﻳﻔﻀﻞ ﺗﻮز ﻳﻌﻬﺎ هﻜﺬ ا '‬ ‫‪If X = 0 Then‬‬ ‫1 = ‪Y‬‬ ‫‪End If‬‬ ‫‪If X = 1 Then‬‬ ‫0 = ‪X‬‬ ‫4 = ‪Y‬‬ ‫‪End If‬‬ ‫‪If Y = 1 Then‬‬ ‫0 = ‪X‬‬ ‫‪Else‬‬ ‫2 = ‪X‬‬ ‫‪End If‬‬
  • 89.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫36‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻣﻼﺣﻈﺔ‬ ‫اﻟﻤﻌﺎﻣﻞ ":" ﻋﻜﺲ اﻟﻤﻌﺎﻣﻞ "_" ﺑﺤﻴﺚ ﻳﻤﻜﻨـﻚ ﻣـﻦ دﻣـﺞ ﻋـﺪة اواﻣـﺮ ﻓـﻲ‬ ‫ﺳﻄﺮ واﺣﺪ.‬ ‫ﺫﻜﺭﺕ ﻤﺭﺘﻴﻥ ﺍﻥ ﺍﻟﻤ ﻔﻀل ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺼﻴﻐﺔ ﺍﻟﻤﻭﺯﻋﺔ ﻭﺍﻏﻼﻗﻬﺎ ﺒـ ‪ End If‬ﺤﻴﺙ ﺍﻨﻬﺎ ﺘﺴـﻬل ﻋﻠﻴـﻙ‬ ‫ﻗﺭﺍﺀﺓ ﻭﻓﻬﻡ ﻤﻨﻁﻕ ﺍﻟﺘﻔﺭﻉ ﺨﺎﺼﺔ ﺍﻥ ﻜﺎﻨﺕ ﺠﻤل ﺍﻟﺸﺭﻁ ﻤﺘﺩﺍﺨﻠﺔ، ﺭﻜﺯ ﻤﻌﻲ ﻴﺎ ﺤﻠﻭ ﻓﻲ ﻫﺫﻩ ﺍﻟﺠﻤل:‬ ‫‪If X = 0 Then‬‬ ‫‪If Y = 0 Then‬‬ ‫001 = ‪X‬‬ ‫‪End If‬‬ ‫‪Else‬‬ ‫1 = ‪Y‬‬ ‫‪End If‬‬ ‫ﻗﺩ ﻴﺄﺘﻲ ﺸﺨﺹ ﻤﺼﻤﻡ ﻋﻠﻰ ﺍﺨﺘﺼﺎﺭ ﺍﻟﺠﻤل ﺍﻟﺴﺎﺒﻘﺔ ﻓﻲ ﺴﻁﺭ ﺍﻟﻭﺍﺤﺩ ) ﻓﻬﻭ ﻤﺒﺭﻤﺞ ﻤﺤﺘـﺭﻑ ﻜﻤـﺎ ﻴـﺩﻋﻲ(‬ ‫ﻭﻴﻜﺘﺏ ﺸﻴﺌﺎ ﻤﺜل:‬ ‫1 = ‪If X = 0 Then If Y = 0 Then X = 100 Else Y‬‬ ‫ﺍﻨﺼﺤﻙ ﺒﻌﺩﻡ ﺍﻻﺴﺘﻤﺎﻉ ﻟﻪ ﻤﺎﺩﺍﻡ ﺍﻟﺤﻤﺎﻡ ﻴﻐﺭﺩ! ﻓﻤﻨﻁﻕ ﺍﻟﺘﻔﺭﻉ ﻓﻲ ﺠﻤﻠﺔ ﺍﺨﻴﻨـﺎ ﻓـﻲ ﺍﷲ ﺨﺎﻁﺌـﺔ، ﺤﻴـﺙ ﺍﻥ‬ ‫ﻜﻠﻤﺔ ‪ Else‬ﺍﻻﺨﻴﺭﺓ ﺘﺘﺒﻊ ﻟﻠﺸﺭﻁ ﺍﻟﺜﺎﻨﻲ ﻭﻟﻴﺱ ﺍﻻﻭل، ﺍﻱ ﺍﻥ ‪ Visual Basic .NET‬ﺴﻴﻔﻬﻤﻬﺎ ﻋﻠﻰ ﺍﻨﻬﺎ:‬ ‫‪If X = 0 Then‬‬ ‫‪If Y = 0 Then‬‬ ‫001 = ‪X‬‬ ‫‪Else‬‬ ‫1 = ‪Y‬‬ ‫‪End If‬‬ ‫‪End If‬‬ ‫ﻭﺤﺘﻰ ﻻ ﻨﻀﻴﻊ ﻭﻗﺘﻨﺎ ﺍﻟﺜﻤﻴﻥ ﻓﻲ ﻤﺜل ﻫﺫﻩ ﺍﻟﺴﺠﺎﻻﺕ، ﺴﺎﻏﻠﻕ ﺍﻟﻤﻭﻀﻭﻉ ﺒﻨﺼﻴﺤﺔ: ﺍﺴـﺘﺨﺩﻡ ﺍﻟﺼـﻴﻐﺔ‬ ‫ﺍﻟﻤﻔﺭﻗﺔ ‪ If … Then … End If‬ﺩﺍﺌﻤﺎ ﺤﺘﻰ ﻟﻭ ﻜﺎﻥ ﺠﻭﺍﺏ ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﺃﻤﺭ ﻭﺍﺤﺩ ﻓﻘﻁ.‬ ‫ﺍﺩﻭﺍﺕ ﺍﻟﺭﺒﻁ ﺍﻟﻤﻨﻁﻘﻲ:‬ ‫ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﺩﻭﺍﺕ ﺍﻟﺭﺒﻁ ﺍﻟﻤﻨﻁﻘﻲ ) ‪... Not ،Or ،And‬ﺍﻟﺦ( ﺒﻁﻼﻗﺔ ﻜﺎﻤﻠﺔ ﻜﻤـﺎ ﺘﻔﻌـل ﻤـﻊ ﻟﻐـﺎﺕ‬ ‫ﺍﻟﺒﺭﻤﺠﺔ ﺍﻻﺨﺭﻯ، ﺤﻴﺙ ﺍﻨﻬﺎ ﻤﺩﻋﻭﻤﺔ ﻓﻲ ‪:Visual Basic .NET‬‬ ‫‪If x > 0 And t < 1 Then‬‬ ‫…‬ ‫…‬ ‫‪End If‬‬ ‫… ‪If Not Y > 1 Then‬‬
  • 90.
    ‫46‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺩﻋﻨﺎ ﻨﻠﻬﻭ ﻗﻠﻴﻼ ﻓﻲ ﻋﻠﻡ ﺍﻟﻤﻨﻁﻕ ﺍﻟﺭﻴﺎﻀﻲ، ﻭﺍﻁﻠﺏ ﻤﻨﻙ ﺍﻟﺘﺭﻜﻴﺯ ﻓﻲ ﺍﻟﺸﺭﻁ ﺍﻟﺘﺎﻟﻲ:‬ ‫‪If X <> 0 And 10 X = 2 Then‬‬ ‫ﻟﻐﻭﻴﺎ، ﺍﻟﺸﺭﻁ ﺍﻟﺴﺎﺒﻕ ﻴﺨﺘﺒﺭ ﻗﻴﻤﺔ ﺍﻟﻤﺘﻐﻴﺭ ‪ X‬ﻤﺎ ﺍﺫﺍ ﻜﺎﻨـﺕ ﺘﺴـﺎﻭﻱ ﺍﻟﺼـﻔﺭ ﺍﻡ ﻻ، ﻭﺍﻥ ﻜﺎﻨـﺕ ﻻ ﺘﺴـﺎﻭﻱ‬ ‫ﺼﻔﺭ ﻓﺴﺘﺨﺘﺒﺭ ﻨﺎﺘﺞ ﺍﻟﻘﺴﻤﺔ. ﻤﻊ ﺫﻟﻙ، ﻓﺈﻥ ﺍﻟﺸﻴﻔﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ ﺴﺘﻅﻬﺭ ﺭﺴﺎﻟﺔ ﺨﻁﺄ ﺍﻥ ﻜﺎﻨﺕ ﻗﻴﻤـﺔ ﺍﻟﻤﺘﻐﻴـﺭ ‪X‬‬ ‫ﺘﺴﺎﻭﻱ ﺼﻔﺭ، ﻭﺍﻟﺴﺒﺏ ﺍﻥ ‪ Visual Basic .NET‬ﺴﻴﺠﺭﻱ ﻋﻤﻠﻴﺔ ﺍﻟﻘﺴﻤﺔ ﺩﺍﺌﻤﺎ. ﻤﻨﻁﻘﻴـﺎ، ﻴﻔﺘـﺭﺽ ﻤـﻥ‬ ‫‪ Visual Basic .NET‬ﺍﻥ ﻻ ﻴﺘﻌﺏ ﻨﻔﺴﻪ ﻭﻴﺠﺭﻱ ﻋﻤﻠﻴﺔ ﺍﻟﻘﺴﻤﺔ ﺍﻥ ﻜﺎﻨـﺕ ﻗﻴﻤـﺔ ﺍﻟﻤﺘﻐﻴـﺭ ‪ X‬ﺘﺴـﺎﻭﻱ‬ ‫ﺼﻔﺭ، ﻭﺍﻟﺴﺒﺏ ﺍﻥ ﺍﻟﻌﺒﺎﺭﺓ ﺴﺘﻜﻭﻥ ﺩﺍﺌﻤﺎ ‪) False‬ﺨﺎﻁﺌﺔ(. ﺘﻘﻨﻴﺎ، ﺍﻟﻤﻌﺎﻤل ‪ And‬ﻴﻘﻭﻡ ﺒﺎﺨﺘﺒﺎﺭ ﺠﻤﻴـﻊ ﺍﻟﺠﻤـل‬ ‫ﺍﻟﺸﺭﻁﻴﺔ ﺍﻟﺘﻲ ﺤﻭﻟﻪ، ﻟﺫﻟﻙ ﻴﻨﺼﺢ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﻌﺎﻤل ‪ AndAlso‬ﻓﻲ ﻤﺜل ﻫﺫﻩ ﺍﻟﺤﺎﻻﺕ:‬ ‫‪If X <> 0 AndAlso 10 X = 2 Then‬‬ ‫ﺍﻥ ﻜﺎﻨﺕ ﻗﻴﻤﺔ ﺍﻟﻤﺘﻐﻴﺭ ‪ X‬ﻓﻲ ﺍﻟﺠﻤﻠﺔ ﺍﻟﺴﺎﺒﻘﺔ ﺘﺴﺎﻭﻱ ﺼﻔﺭ، ﻓﺎﻥ ‪ Visual Basic .NET‬ﻟﻥ ﻴﻜﻤل ﻋﻤﻠﻴـﺔ‬ ‫ﺍﻟﺘﺤﻘﻕ ﻤﻥ ﻋﻤﻠﻴﺔ ﺍﻟﻘﺴﻤﺔ ﻤﻤﺎ ﻴﺠﻨﺒﻨﺎ ﻅﻬﻭﺭ ﺭﺴﺎﻟﺔ ﺍﻟﺨﻁﺄ.‬ ‫ﺍﻟﻰ ﺠﺎﻨﺏ ﺍﻟﻤﻌﺎﻤل ‪ AndAlso‬ﻴﻭﺠﺩ ﻤﻌﺎﻤل ﺍﺨﺭ ﻫﻭ ‪ OrElse‬ﻭﺍﻟﺫﻱ ﺴﻴﺘﺨﻁﻰ ﺍﻟﺸـﺭﻁ ﺍﻟﺜـﺎﻨﻲ ﺍﻥ‬ ‫ﻜﺎﻥ ﺍﻻﻭل ‪:True‬‬ ‫ﻟﻦ ﻳﺘﻢ ا ﻟﺘﺤﻘﻖ ﻣﻦ ا ﻟﺸﺮط اﻟﺜﺎﻧ ﻲ '‬ ‫ان آﺎ ن اﻟﻌ ﺪد ﰲ اﳌﺘﻐ ﲑ ‪' X‬‬ ‫ﻣﻮﺟﺐ '‬ ‫… ‪If X > 0 OrElse Y < 0 Then‬‬ ‫ﻋﻠﻴﻙ ﻤﻌﺭﻓﺔ ﺍﻥ ﺍﻟﻤﻌـﺎﻤﻼﺕ ‪ AndAlso‬ﻭ ‪ OrElse‬ﺘﺘﻌﺎﻤـل ﻤـﻊ ﺍﻟﻘـﻴﻡ ﺍﻟﻤﻨﻁﻘﻴـﺔ ﻓﻘـﻁ، ﻭﺍﻥ‬ ‫ﺍﺴﺘﺨﺩﻤﺕ ﺍﻻﻋﺩﺍﺩ )ﺴﺘﺠﺭﻯ ﻋﻤﻠﻴﺔ ﺍﻟﺘﺤﻭﻴل ﺍﻟﺘﻠﻘﺎﺌﻲ ﻓﻲ ﺤﺎﻟـﺔ ‪ (Option Strict Off‬ﻓﺴـﺘﻌﺘﺒﺭ ﺍﻱ ﻗﻴﻤـﺔ‬ ‫ﻏﻴﺭ ﺍﻟﺼﻔﺭ ‪ ،True‬ﺒﻴﻨﻤﺎ ﺍﻟﻤﻌﺎﻤﻼﺕ ‪ And‬ﻭ ‪ Or‬ﺘﺨﺘﺒﺭ ﺍﻟﺒﺘﺎﺕ ﺍﻟﺘـﻲ ﺘﻜـﻭﻥ ﺍﻟﻌـﺩﺩ –ﻟـﺫﻟﻙ ﺘﺴـﻤﻰ -‪bit‬‬ ‫‪ ،wise operators‬ﻓﺠﻤﻠﺔ ﺍﻟﺸﺭﻁ ﺍﻟﺘﺎﻟﻴﺔ:‬ ‫3 = ‪x‬‬ ‫21 = ‪y‬‬ ‫‪If x <> 0 And y <> 0 Then … ' True‬‬ ‫ﻴﻤﻜﻨﻙ ﺍﺨﺘﺼﺎﺭﻫﺎ ﺒﺎﻟﻤﻌﺎﻤل ‪ AndAlso‬ﻟﺘﻌﻁﻲ ﻨﺘﻴﺠﺔ ﻤﻤﺎﺜﻠﺔ:‬ ‫ﻋﻤﻠﻴﺔ اﳌ ﻘﺎﻧﺔ ﲣﺘﱪ ا ﻟﻘﻴ ﻢ '‬ ‫‪' True And True = True‬‬ ‫… ‪If x AndAlso y Then‬‬ ‫ﺒﻴﻨﻤﺎ ﻴﺅﺩﻱ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﻌﺎﻤل ‪ And‬ﺍﻟﻰ ﺍﺨﺘﺒﺎﺭ ﺍﻟﺒﺘﺎﺕ ﺍﻟﻤﻜﻭﻨﺔ ﻟﻼﻋﺩﺍﺩ، ﻟﺘﻌﻁﻲ ﻨﺘﻴﺠﺔ ﺨﺎﻁﺌﺔ:‬ ‫ﻋﻤﻠﻴﺔ اﳌ ﻘﺎرﻧﺔ ﲣﺘﱪ اﻟﺒﺘﺎ ت '‬ ‫)‪' 0011 And 1100 = 0000 (False‬‬ ‫… ‪If x And y Then‬‬
  • 91.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫56‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺍﺨﻴﺭﺍ، ﻴﻤﻜﻨﻙ ﺍﺨﺘﺒﺎﺭ ﻤﺠﻤﻭﻋﺔ ﺠﻤل ﺸﺭﻁﻴﺔ ﻭﺘﻨﻔﻴـﺫ ﺍﻭﺍﻤـﺭ ﻤﻌﻴﻨـﻪ ﺍﻥ ﺍﺨﻔﻘـﺕ ﻜﻠﻬـﺎ ﺒﺎﺴـﺘﺨﺩﺍﻡ‬ ‫‪:ElseIf‬‬ ‫‪If X = 1 Then‬‬ ‫…‬ ‫‪ElseIf X = 2 Then‬‬ ‫…‬ ‫‪ElseIf X = 3 Then‬‬ ‫…‬ ‫‪Else‬‬ ‫…‬ ‫‪End If‬‬ ‫اﻟﺘﻔﺮع ﺑﺎﺳﺘﺨﺪام ‪Select Case‬‬ ‫ﺍﻟﺘﻔﺭﻉ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪ Select Case‬ﻴﻤﻜﻥ ﺘﻁﺒﻴﻘﻪ ﺒﺴﻬﻭﻟﺔ ﺘﺎﻤﺔ:‬ ‫)"ﳏﺮ م"(‬ ‫)"ﺻﻔ ﺮ"(‬ ‫)"ذو اﳊ ﺠ ﺔ"(‬ ‫)"ﻏﲑ ﻣﻌ ﺮ ف"(‬ ‫‪Dim X As Integer‬‬ ‫…‬ ‫…‬ ‫‪Select Case X‬‬ ‫1 ‪Case‬‬ ‫‪ArabicConsole.WriteLine‬‬ ‫2 ‪Case‬‬ ‫‪ArabicConsole.WriteLine‬‬ ‫…‬ ‫…‬ ‫21 ‪Case‬‬ ‫‪ArabicConsole.WriteLine‬‬ ‫‪Case Else‬‬ ‫‪ArabicConsole.WriteLine‬‬ ‫‪End Select‬‬ ‫ﺘﻜﻤﻥ ﻗﻭﺓ ﺍﻟﻌﺒﺎﺭﺓ ‪ Select Case‬ﻓﻲ ﺘﻁﺒﻴﻕ ﺍﻟﻤﻌﺎﻤﻼﺕ ﺍﻟﻤﻨﻁﻘﻴﺔ ﺍﻭ ﺘﺤﺩﻴﺩ ﻤﺠﺎﻻﺕ ﻟﻠﻘﻴﻡ ﺍﻟﻤﻁﻠـﻭﺏ‬ ‫ﺍﻟﺘﺤﻘﻕ ﻤﻨﻬﺎ:‬ ‫)"راﺳ ﺐ"(‬ ‫)"ﻣﻘﺒﻮ ل"(‬ ‫)"ﺟﻴ ﺪ"(‬ ‫)"ﺟﻴﺪ ﺟ ﺪ ا"(‬ ‫)"ﳑﺘﺎ ز"(‬ ‫‪Dim Grade As Integer‬‬ ‫…‬ ‫…‬ ‫‪Select Case Grade‬‬ ‫06 < ‪Case Is‬‬ ‫‪ArabicConsole.WriteLine‬‬ ‫96 ‪Case 60 To‬‬ ‫‪ArabicConsole.WriteLine‬‬ ‫97 ‪Case 70 To‬‬ ‫‪ArabicConsole.WriteLine‬‬ ‫98 ‪Case 80 To‬‬ ‫‪ArabicConsole.WriteLine‬‬ ‫09 => ‪Case Is‬‬ ‫‪ArabicConsole.WriteLine‬‬ ‫‪End Select‬‬
  • 92.
    ‫66‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺍﻟﻤﺯﻴﺩ ﺍﻴﻀﺎ، ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻔﺎﺼﻠﺔ ﺒﻤﺭﻭﻨﺔ ﻜﺎﻤﻠﺔ، ﻭﺒﻨﻔﺱ ﺍﻟﻤﻨﻁﻕ ﺍﻟﺴﺎﺒﻕ:‬ ‫‪Dim Letter As Char‬‬ ‫…‬ ‫…‬ ‫‪Select Case Letter‬‬ ‫‪Case "A"c To "Z"c, "a"c To "z"c‬‬ ‫)"ﺣﺮف ا ﲜﺪ ي"( ‪ArabicConsole.WriteLine‬‬ ‫‪Case "0"c To "9"c‬‬ ‫)"ﻋﺪ د"( ‪ArabicConsole.WriteLine‬‬ ‫‪Case "."c, ":"c, " "c, ";"c, "?"c‬‬ ‫)"رﻣ ﺰ"( ‪ArabicConsole.WriteLine‬‬ ‫‪Case Else‬‬ ‫)"ﻏﲑ ﻣﻌ ﺮو ف"( ‪ArabicConsole.WriteLine‬‬ ‫‪End Select‬‬ ‫ﺍﻟﻔﺎﺼﻠﺔ ﺍﻟﺘﻲ ﺍﺴﺘﺨﺩﻤﻨﺎﻫﺎ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﺘﻤﺜل ﺍﺩﺍﺓ ﺍﻟﺭﺒﻁ ‪ Or‬ﺍﻟﻤﻨﻁﻘﻴﺔ:‬ ‫‪Select Case True‬‬ ‫0 < ‪Case x > 0, Y‬‬ ‫ﺗﻌﺎد ل '‬ ‫)0 < ‪' If (X > 0) Or (Y‬‬ ‫…‬ ‫‪End Select‬‬ ‫‪Select Case False‬‬ ‫0 < ‪Case x > 0, Y‬‬ ‫ﺗﻌﺎد ل '‬ ‫) )0 < ‪' If ( Not (X > 0) ) Or ( Not (Y‬‬ ‫…‬ ‫‪End Select‬‬ ‫اﻟﺤﻠﻘﺎت اﻟﺘﻜﺮارﻳ ﺔ‬ ‫ﺤﺩﺩ ﺍﻟﻘﻴﻤﺔ ﺍﻻﺒﺘﺩﺍﺌﻴﺔ ﻭﺍﻟﻨﻬﺎﺌﻴﺔ ﻟﺤﻠﻘﺔ ‪:For … Next‬‬ ‫‪Dim counter As Integer‬‬ ‫4 ‪For counter = 2 To‬‬ ‫ﺛﻼث ﻣ ﺮا ت ' )‪ArabicConsole.WriteLine(counter‬‬ ‫‪Next‬‬ ‫ﺘﺴﺘﻁﻴﻊ ﺍﻟﺘﺤﻜﻡ ﻓﻲ ﻤﻘﺩﺍﺭ ﺍﻟﺯﻴﺎﺩﺓ ﺍﻭﺍﻟﻨﻘﺼﺎﻥ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪:Step‬‬ ‫1- ‪For counter = 5 To 1 Step‬‬ ‫…‬ ‫‪Next‬‬
  • 93.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫76‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻀﻊ ﻓﻲ ﺍﻋﺘﺒﺎﺭﻙ ﺍﻥ ﻤﺘﻐﻴﺭ ﺍﻟﺤﻠﻘﺔ ﺴﻴﺯﻴﺩ ﺍﻭ ﻴﻨﻘﺹ ﺒﺎﻟﻤﻘﺩﺍﺭ ﺍﻟﻤﺤﺩﺩ ﺤﺘﻰ ﺒﻌﺩ ﻨﻬﺎﻴﺔ ﺍﻟﺤﻠﻘﺔ:‬ ‫1- ‪For counter = 5 To 1 Step‬‬ ‫…‬ ‫‪Next‬‬ ‫ﻗﻴﻤﺔ اﻟﻌ ﺪاد 0 وﻟﻴﺲ 1 '‬ ‫0 ' )‪ArabicConsole.WriteLine(counter‬‬ ‫ﺍﻟﻤﺯﺍﺡ ﻤﻊ ﻤﺘﻐﻴﺭ ﺍﻟﺤﻠﻘﺔ ﺩﺍﺨل ﺍﻟﺤﻠﻘﺔ ﻓﻴﻪ ﺸﺊ ﻤﻥ ﺍﻟﺨﻁﺭ، ﻓﻌﺩﺩ ﻤﺭﺍﺕ ﺍﻟﺘﻜﺭﺍﺭ ﻟﻠﺤﻠﻘﺔ ﺍﻟﺘﺎﻟﻴـﺔ ﻫـﻭ‬ ‫ﻭﺍﺤﺩ ﻓﻘﻁ:‬ ‫001 ‪For counter = 1 To‬‬ ‫001 = ‪counter‬‬ ‫…‬ ‫‪Next‬‬ ‫ﻭﻗﺒل ﺍﻨﺘﻬﺎﺀ ﺍﻟﻤﺩﺓ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ﻟﻠﺤﻠﻘﺔ، ﻴﻤﻜﻨﻙ ﻗﻁﻌﻬﺎ ﻭﺍﻨﻬﺎﺌﻬﺎ ﺒﻌﺒﺎﺭﺓ ‪:Exit For‬‬ ‫05 ‪For counter = 1 To‬‬ ‫…‬ ‫‪If y = 10 Then‬‬ ‫‪Exit For‬‬ ‫‪End If‬‬ ‫…‬ ‫‪Next‬‬ ‫ﺤﻠﻘﺔ ﺍﺨﺭﻯ ﺠﻤﻴﻠﺔ ﺠﺩﺍ ﺘﻌﺭﻑ ﺒـ ‪ For Each‬ﺘﻁﺒﻕ ﻋﻠﻰ ﺍﻟﻤﺼـﻔﻭﻓﺎﺕ ‪ Arrays‬ﺍﻭ ﺍﻟﻤﺠﻤﻭﻋـﺎﺕ‬ ‫‪:Collections‬‬ ‫‪Dim x(5) As Integer‬‬ ‫‪Dim y As Integer‬‬ ‫…‬ ‫…‬ ‫‪For Each y In x‬‬ ‫)‪ArabicConsole.WriteLine(y‬‬ ‫‪Next‬‬ ‫ﻣﻼﺣﻈﺔ‬ ‫ا ن آﻨﺖ ﻣﺒﺘﺪءً، ﻓﻼ ﺗﺴﺘﺨﺪم اﻟﺤﻠﻘﺔ ‪ For Each‬آﺜﻴـﺮا هـﺬﻩ اﻻﻳـﺎم ﺣﺘـﻰ‬ ‫ا‬ ‫ً‬ ‫ﺗ ﺼﻞ اﻟﻰ اﻟﻔ ﺼﻞ اﻟﺨﺎﻣﺲ اﻟﻮاﺟﻬـﺎت، اﻟﺘﻔـﻮﻳﺾ، واﻟﻤﻮاﺻـﻔﺎت ، ﺣﻴـﺚ‬ ‫ﺳﺘﺠﺪ اﻟﻤﺰﻳﺪ ﻣﻦ اﻟﺘﻔﺎ ﺻﻴﻞ ﻋﻦ اﺳﺘﺨﺪام هﺬﻩ اﻟﺤﻠﻘﺔ.‬
  • 94.
    ‫86‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻭﻋﻨﺩ ﺍﻟﺤﺩﻴﺙ ﻋﻥ ﺍﻟﺤﻠﻘﺎﺕ ﺍﻟﻼﻨﻬﺎﺌﻴﺔ، ﻓﻠﻥ ﺘﺠﺩ ﺍﻓﻀل ﻤﻥ ﺤﻠﻘﺔ ‪ Do … Loop‬ﺍﻟﻤﺭﻨﺔ ﺠـﺩﺍ، ﺤﻴـﺙ‬ ‫ﺘﻤﻜﻨﻙ ﻤﻥ ﻭﻀﻊ ﺍﻟﺸﺭﻁ ﺍﻤﺎ ﻓﻲ ﺍﻋﻠﻰ ﺍﻟﺤﻠﻘﺔ ﺍﻭ ﻓﻲ ﺍﺴﻔﻠﻬﺎ )ﻟﻴﺘﻡ ﺘﻨﻔﻴﺫ ﺍﻭﺍﻤﺭ ﺍﻟﺤﻠ ﻘﺔ ﻤﺭﺓ ﻭﺍﺤﺩﺓ ﻋﻠﻰ ﺍﻻﻗـل‬ ‫ﻓﻲ ﺤﺎﻟﺔ ﻭﻀﻊ ﺍﻟﺸﺭﻁ ﺍﺴﻔل ﺍﻟﺤﻠﻘﺔ(. ﺍﻥ ﺍﺴﺘﺨﺩﻤﺕ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ ،Until‬ﺴﻴﺘﻡ ﺘﻜـﺭﺍﺭ ﺍﻟﺤﻠﻘـﺔ ﺤﺘـﻰ‬ ‫ﻴﺼﺒﺢ ﺍﻟﺸﺭﻁ ‪ ،True‬ﺍﻤﺎ ﺍﻥ ﻜﺎﻨﺕ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪ While‬ﻫﻲ ﺍﻟﻤﺭﺍﻓﻘﺔ، ﻓﺴﻴﺘﻡ ﺘﻜﺭﺍﺭ ﺍﻟﺤﻠﻘﺔ ﻤﺎ ﺩﺍﻤـﺕ‬ ‫ﻗﻴﻤﺔ ﺍﻟﺸﺭﻁ ‪:True‬‬ ‫‪", MsgBoxStyle.YesNo) = MsgBoxResult.Yes‬ا‪‬ﻲ اﳊﻠﻘ ﺔ ؟"(‪Do Until MsgBox‬‬ ‫…‬ ‫‪Loop‬‬ ‫‪", MsgBoxStyle.YesNo) = MsgBoxResult.No‬ا‪‬ﻲ اﳊﻠﻘ ﺔ ؟"(‪Do While MsgBox‬‬ ‫…‬ ‫‪Loop‬‬ ‫ﺍﺨﻴﺭﺍ، ﺘﺴﺘﻁﻴﻊ ﻓﻲ ﺍﻱ ﻟﺤﻅﺔ ﺍﻟﺨﺭﻭﺝ ﻤﻥ ﺍﻟﺤﻠﻘﺔ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻌﺒﺎﺭﺓ ‪.Exit Do‬‬ ‫ﺍﻟﺘﺒﺩﻴل ﺒﻴﻥ ‪ For … Next‬ﻭ ‪:Do … Loop‬‬ ‫ﺘﺴﺘﻁﻴﻊ ﺘﺤﻭﻴل ﺤﻠﻘﺔ ‪ For … Next‬ﺍﻟﻰ ﺤﻠﻘﺔ ‪ Do … Loop‬ﻭﺍﻟﻌﻜﺱ ﺼﺤﻴﺢ، ﻟﻜﻥ ﻋﻠﻴﻙ ﺍﻻﻨﺘﺒـﺎﻩ ﺍﻟـﻰ‬ ‫ﺍﻥ ﺍﻟﻘﻴﻡ ﺍﻟﺘﻲ ﺘﺤﺩﺩﻫﺎ ﻓﻲ ﺒﺩﺍﻴﺔ ﺍﻟﺤﻠﻘﺔ ‪ For … Next‬ﺘﻤﺜل ﻋﺩﺩ ﺍﻟﺘﻜﺭﺍﺭ ﺤﺘﻰ ﻭﺍﻥ ﺘﻐﻴﺭﺕ ﺩﺍﺨـل ﺍﻟﺤﻠﻘـﺔ،‬ ‫ﻓﺒﺎﻟﺭﻏﻡ ﻤﻥ ﺍﻥ ﺍﻟﺤﻠﻘﺘﻴﻥ ﺍﻟﺘﺎﻟﻴﺘﻴﻥ ﻤﺘﺸﺎﺒﻬﺘﻴﻥ:‬ ‫5 = ‪A‬‬ ‫ﺣﻠﻘ ﺔ ‪' For … Next‬‬ ‫‪For counter = 1 To A‬‬ ‫…‬ ‫‪Next‬‬ ‫ﲢﻮﻳﻠﻬﺎ ا ﱃ ‪' Do … Loop‬‬ ‫1 = ‪counter‬‬ ‫‪Do‬‬ ‫…‬ ‫1 + ‪counter = counter‬‬ ‫‪Loop Until counter > A‬‬ ‫ﺍﻻ ﺍﻥ ﺍﻻﺨﺘﻼﻑ ﺴﻴﻅﻬﺭ ﻓﻲ ﺤﺎل ﻤﺎ ﺍﺫﺍ ﺘﻡ ﺘﻐﻴﻴﺭ ﻗﻴﻤﺔ ﺍﻟﻤﺘﻐﻴﺭ ‪ ،A‬ﻓﺎﻟﺤﻠﻘﺔ ﺍﻻﻭﻟـﻰ ‪ For … Next‬ﺴـﻴﺘﻡ‬ ‫ﺘﻨﻔﻴﺫﻫﺎ ﺩﺍﺌﻤﺎ ﺨﻤﺱ ﻤﺭﺍﺕ ﺤﺘﻰ ﻭﺍﻥ ﺘﻐﻴﺭﺕ ﻗﻴﻤﺔ ﺍﻟﻤﺘﻐﻴﺭ ‪ A‬ﻓﻲ ﺩﺍﺨل ﺍﻟﺤﻠﻘﺔ، ﺒﻴﻨﻤﺎ ﺘﻐﻴﻴـﺭ ﻗﻴﻤـﺔ ﺍﻟﻤﺘﻐﻴـﺭ‬ ‫ﻴﺅﺜﺭ ﺒﺸﻜل ﻜﺒﻴﺭ ﻋﻠﻰ ﻋﺩﺩ ﻤﺭﺍﺕ ﺘﻜﺭﺍﺭ ﺍﻟﺤﻠﻘﺔ ﺍﻻﺨﺭﻯ ‪.Do … Loop‬‬
  • 95.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫96‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻣﺠﺎﻻت اﻻﺳﻤﺎء ‪Namespaces‬‬ ‫ﺍﻟﻔﻜﺭﺓ ﻤﻥ ﻤﺠﺎﻻﺕ ﺍﻻﺴﻤﺎﺀ ‪ Namespaces‬ﺘﻘﺘﻀـﻲ ﺘﻭﺯﻴـﻊ ﺍﻻﺴـﻤﺎﺀ ﺍﻟﻤﺘﺸـﺎﺒﻬﺔ ﻟﻤﻌﺭﻓـﺎﺕ ﺍﻟﺒﺭﻨـﺎﻤﺞ‬ ‫)ﻜﺎﺴﻤﺎﺀ ﺍﻟﻔﺌﺎﺕ ‪ ،Classes‬ﺍﻟﻭﺤﺩﺍﺕ ﺍﻟﺒﺭﻤﺠﻴﺔ ‪ ،Modules‬ﺍﻟﺘﺭﻜﻴﺒﺎﺕ ‪ ... Structures‬ﺍﻟـﺦ( ﺍﻟـﻰ ﻜﺘـل‬ ‫ﻤﺨﺘﻠﻔﺔ ﺘﺴﻤﻰ ﻤﺠﺎل ﺍﻻﺴﻤﺎﺀ ‪ ،Namespace‬ﺒﺤﻴﺙ ﺘﺴـﻬل ﻋﻠﻴـﻙ ﺘﺭﺘﻴـﺏ ﺍﺴـﻤﺎﺌﻬﺎ ﻋﻠـﻰ ﻤﺠﻤﻭﻋـﺎﺕ،‬ ‫ﻭﺘﻤﻜﻨﻙ ﺍﻴﻀﺎ ﻤﻥ ﺘﻌﺭﻴﻑ ﺍﺴﻤﺎﺀ ﻤﺘﺸﺎﺒﻬﻪ ﻟﻤﻌﺭﻓﺎﺕ ﻤﺨﺘﻠﻔﺔ. ﻓﻠﻭ ﻋﺭﻓﻨﺎ ﺘﺭﻜﻴﺏ ﻟﻠﻔﺄﺭ ﺒﺎﺴﻡ ‪:Mouse‬‬ ‫‪Structure Mouse‬‬ ‫…‬ ‫…‬ ‫‪End Structure‬‬ ‫ﻓﻼ ﻴﻤﻜﻨﻨﺎ ﺍﺴﺘﺨﺩﺍﻡ ﻨﻔﺱ ﺍﻻﺴﻡ ﻟﺘﻌﺭﻴﻑ ﺘﺭﻜﻴﺏ ﺍﺨﺭ -ﻴﻤﺜل ﺠﻬﺎﺯ ﺍﻟﻔـﺄﺭﺓ - ﺒـﻨﻔﺱ ﺍﻻﺴـﻡ ‪ .Mouse‬ﻟـﺫﻟﻙ‬ ‫ﺴﻨﻘﻭﻡ ﺒﺘﻌﺭﻴﻑ ﻤﺠﺎﻻﺕ ﺍﺴﻤﺎﺀ ﻤﺨﺘﻠﻔﺔ.‬ ‫ﺗﻌﺮﻳﻒ ﻣﺠﺎل اﺳﻤﺎء‬ ‫ﻗﺒل ﺍﻥ ﺘﺒﺩﺃ ﺒﺘﻌﺭﻴﻑ ﻤﺠﺎﻻﺕ ﺍﺴﻤﺎﺀ ﺨﺎﺼﺔ ﺒـﻙ، ﻋﻠﻴـﻙ ﻤﻌﺭﻓـﺔ ﺍﻥ ﺍﻟﻤﺸـﺭﻭﻉ ‪ Project‬ﺍﻟﺤـﺎﻟﻲ ﺍﻟـﺫﻱ‬ ‫ﺘﺼﻤﻤﻪ ﻗﺩ ﻋﺭﻑ ﻤﺠﺎل ﺍﺴﻡ ﺠﺩﻴﺩ، ﻭﻴﻜﻭﻥ ﺍﺴﻤﻪ -ﺒﺸﻜل ﻤﺒﺩﺌﻲ - ﻨﻔـﺱ ﺍﺴـﻡ ﺍﻟﻤﺸـﺭﻭﻉ. ﻴﻤﻜﻨـﻙ ﺘﻐﻴﻴـﺭ‬ ‫ﻤﺠﺎل ﺍﻻﺴﻡ ﻤﻥ ﻨﺎﻓﺫﺓ ‪ ،Project Property Pages‬ﻭﻤﻥ ﺜﻡ ﻜﺘﺎﺒﺔ ﺍﺴﻡ ﻤﺠﺎل ﺍﻻﺴﻤﺎﺀ ﻓـﻲ ﺨﺎﻨـﺔ ‪Root‬‬ ‫‪) namespace‬ﺸﻜل 2 -5(.‬ ‫ﺸﻜل 2 -5: ﺘﺴﻴﻤﺔ ﻤﺠﺎل ﺍﻻﺴﻤﺎﺀ ﺍﻟﺠﺫﺭﻱ ﻟﻠﻤﺸﺭﻭﻉ.‬
  • 96.
    ‫07‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻫﺫﺍ ﺍﻻﺴﻡ ﺍﻟﺫﻱ ﺍﺨﺘﺭﺘﻪ ﻴﻤﺜل ﻤﺠﺎل ﺍﻻﺴﻤﺎﺀ ﺍﻟﺠﺫﺭﻱ ﻭﺍﻟﺭﺌﻴﺴـﻲ ﻟﻠﻤﺸـﺭﻭﻉ ﺍﻟﺤـﺎﻟﻲ، ﻭﺠﻤﻴـﻊ ﺍﻟﻤﻌﺭﻓـﺎﺕ‬ ‫ﻭﻤﺠﺎﻻﺕ ﺍﻻﺴﻤﺎﺀ ﺍﻻﺨﺭﻯ ﺘﺎﺒﻌﺔ ﺍﻭ ﺩﺍﺨﻠﺔ -ﺍﻥ ﺼﺢ ﺍﻟﺘﻌﺒﻴﺭ - ﻀﻤﻥ ﺤﻴﺯ ﻫﺫﺍ ﺍﻟﻤﺠﺎل.‬ ‫ﺒﺭﻤﺠﻴﺎ، ﻴﻤﻜﻥ ﺘﻌﺭﻴﻑ ﺍﻟﻤﺯﻴﺩ ﻤﻥ ﻤﺠﺎﻻﺕ ﺍﻻﺴﻤﺎﺀ ﻓﻲ ﺩﺍﺨل ﻤﺸﺭﻭﻋﻙ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤـﺔ ﺍﻟﻤﺤﺠـﻭﺯﺓ‬ ‫‪ Namespace‬ﻭﺘﺫﻴﻴل ﺍﻟﻤﺠﺎل ﺒﺎﻟﻌﺒﺎﺭﺓ ‪:End Namespace‬‬ ‫‪Namespace Devices‬‬ ‫…‬ ‫…‬ ‫‪End Namespace‬‬ ‫ﻴﻤﻜﻨﻙ ﺍﻟﺒﺩﺀ ﺒﺎﻀﺎﻓﺔ ﻜل ﺍﻟﻤﻌﺭﻓﺎﺕ ﺍﻟﺘﻲ ﺘﺭﻏﺏ ﺒﺤﻀﻨﻬﺎ ﺩﺍﺨـل ﻫـﺫﺍ ﺍﻟﻤﺠـﺎل، ﻭﺍﻟﻤﻌﺭﻓـﺎﺕ ﺍﻟﺘـﻲ‬ ‫ﻴﻤﻜﻨﻙ ﺘﻌﺭﻴﻔﻬﺎ ﻓﻲ ﺩﺍﺨل ﻤﺠﺎل ﺍﻻﺴـﻤﺎﺀ ﻫـﻲ ﺍﻤـﺎ ﺃﻥ ﺘﻜـﻭﻥ ﻓﺌـﺎﺕ ‪ ،Classes‬ﺍﻭ ﻭﺤـﺩﺍﺕ ﺒﺭﻤﺠـﺔ‬ ‫‪ ،Modules‬ﺍﻭ ﺘﺭﻜﻴﺒﺎﺕ ‪ ،Structures‬ﺍﻭ ﻭﺍﺠﻬﺎﺕ ‪ Interfaces‬ﺍﻭ ﺘﺭﻜﻴﺒﺎﺕ ﻤﻥ ﺍﻟﻨﻭﻉ ‪ Enum‬ﻓﻘﻁ:‬ ‫‪Namespace Devices‬‬ ‫‪Structure Mouse‬‬ ‫…‬ ‫…‬ ‫‪End Structure‬‬ ‫‪Structure Printer‬‬ ‫…‬ ‫…‬ ‫‪End Structure‬‬ ‫…‬ ‫…‬ ‫‪End Namespace‬‬ ‫‪Namespace Animals‬‬ ‫‪Structure Mouse‬‬ ‫…‬ ‫…‬ ‫‪End Structure‬‬ ‫‪Structure Cat‬‬ ‫…‬ ‫…‬ ‫‪End Structure‬‬ ‫…‬ ‫…‬ ‫‪End Namespace‬‬ ‫اﻧﻈﺮ اﻳﻀﺎ‬ ‫ﺳﻴﺘﻢ اﻟﺤﺪﻳﺚ ﻋﻦ اﻟﻔﺌﺎت ‪ Classes‬ﻓﻲ اﻟﻔ ﺼﻞ اﻟﺜﺎﻟﺚ اﻟﻔﺌﺎت واﻟﻜﺎﺋﻨـﺎت ،‬ ‫واﻟﻮاﺟﻬــﺎت ‪ Interfaces‬ﻓــﻲ اﻟﻔ ﺼــﻞ اﻟﺨــﺎﻣﺲ اﻟﻮاﺟﻬــﺎت ، اﻟﺘﻔــﻮﻳﺾ،‬ ‫واﻟﻤﻮاﺻﻔﺎت. اﻣﺎ اﻟﻮﺣـﺪات اﻟﺒﺮﻣﺠﻴـﺔ ‪ Modules‬واﻟﺘﺮآﻴﺒـﺎت -ﺳـﻮاء آﺎﻧـﺖ‬ ‫‪ Enums‬او ‪ Structures‬ﻓﻘﺪ ﻓ ﺼﻠﺘﻬﺎ ﺳﺎﺑﻘﺎ ﻓﻲ هﺬا اﻟﻔ ﺼﻞ.‬
  • 97.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫17‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺍﺨﻴﺭﺍ، ﻤﺠﺎﻻﺕ ﺍﻻﺴﻤﺎﺀ ﻤﻤﻜﻥ ﺍﻥ ﺘﻜﻭﻥ ﻤﺘﺩﺍﺨﻠﺔ ‪:Nested‬‬ ‫‪Namespace Devices‬‬ ‫‪Namespace Inputs‬‬ ‫‪Structure Mouse‬‬ ‫…‬ ‫…‬ ‫‪End Structure‬‬ ‫‪Structure Keyboard‬‬ ‫…‬ ‫…‬ ‫‪End Structure‬‬ ‫…‬ ‫…‬ ‫‪End Namespace‬‬ ‫‪Namespace Outputs‬‬ ‫‪Structure Monitor‬‬ ‫…‬ ‫…‬ ‫‪End Structure‬‬ ‫‪Structure Printer‬‬ ‫…‬ ‫…‬ ‫‪End Structure‬‬ ‫…‬ ‫…‬ ‫‪End Namespace‬‬ ‫…‬ ‫…‬ ‫‪End Namespace‬‬ ‫اﻟﻮﺻﻮل اﻟﻰ ﻋﻨﺎﺻﺮ ﻣﺠﺎل اﻻﺳﻤﺎء‬ ‫ﻜل ﻤﺎ ﻫﻭ ﻤﻁﻠﻭﺏ ﻤﻨﻙ ﺘﺤﺩﻴﺩ ﺍﺴﻡ ﻤﺠﺎل ﺍﻻﺴﻤﺎﺀ ﻭﻤﻥ ﺜﻡ ﺫﻜﺭ ﺍﻟﻤﻌﺭﻑ ﺍﻟﺫﻱ ﺘﺭﻏﺏ ﻓﻲ ﺍﺴﺘﺨﺩﺍﻤﻪ:‬ ‫‪Dim X As Animals.Mouse‬‬ ‫‪Dim Y As Devices.Mouse‬‬ ‫…‬ ‫…‬ ‫ﻭﺒﺎﻟﻨﺴﺒﺔ ﻟﻤﺠﺎﻻﺕ ﺍﻻﺴﻤﺎﺀ ﺍﻟﻤﺘﺩﺍﺨﻠﺔ، ﻋﻠﻴﻙ ﺫﻜﺭ ﺠﻤﻴﻊ ﺍﻟﻤﺠﺎﻻﺕ ﺍﻟﺤﺎﻀـﻨﺔ ﻟﻬـﺎ، ﻭﺒـﻨﻔﺱ ﺍﻟﺘﺭﺘﻴـﺏ‬ ‫ﺍﻟﻤﻨﻁﻘﻲ ﺍﻟﺫﻱ ﺘﺘﺒﻌﻪ ﻟﻠﻭﺼﻭل ﺇﻟﻰ ﻋﻨﺎﺼﺭ ﺘﺭﻜﻴﺒﺎﺕ ‪ Structures‬ﻤﺘﺩﺍﺨﻠﺔ:‬ ‫‪Dim X As Devices.OutPuts.Printer‬‬ ‫‪Dim Y As Devices.OutPuts.Screen‬‬ ‫‪Dim Z As Devices.Inputs.Keyboard‬‬
  • 98.
    ‫27‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺍﺴﺘﺨﺩﻡ ﺍﻻﺴﻡ ﺍﻟﻜﺎﻤل ﻟﻤﺠﺎل ﺍﻻﺴﻤﺎﺀ ﺍﻥ ﻜﻨﺕ ﺨﺎﺭﺝ ﺍﻟﻤﺠﺎل ﻓﻘﻁ )ﻜﻤﺎ ﻓﻲ ﺍﻻﻤﺜﻠﺔ ﺍﻟﺴـﺎﺒﻘﺔ(، ﺍﻤـﺎ ﺇﻥ‬ ‫ﻜﻨﺕ ﺩﺍﺨل ﺍﻟﻤﺠﺎل ﻓﻼﻴﻭﺠﺩ ﺩﺍﻋﻲ ﻟﺘﺤﺩﻴﺩ ﺍﺴﻡ ﺍﻟﻤﺠﺎل ﺍﻟﺤﺎﻟﻲ:‬ ‫داﺧﻞ ﳎﺎل اﻻﲰﺎ ء ‪' Devices.Inputs‬‬ ‫‪Dim X As Keyboard‬‬ ‫‪Dim Y As Mouse‬‬ ‫هﻨﺎ اﺳﺘﺨ ﺪﻣﺖ ﳎ ﺎل ﺧﺎ رﺟﻲ ا ﺧ ﺮ ' ‪Dim Z As OutPuts.Printer‬‬ ‫اﺳﺘﻴﺮاد ﻣﺠﺎل اﺳﻤﺎء ﺑﺎﺳﺘﺨﺪام ‪Imports‬‬ ‫ﻴﻘﺼﺩ ﺒﺠﻤﻠﺔ ﺍﺴﺘﻴﺭﺍﺩ ﻤﺠﺎل ﺍﺴﻤﺎﺀ ﺍﻱ ﺘﻀﻤﻴﻥ ﻤﺠﺎل ﺍﺴﻤﺎﺀ ﻤﻌﻴﻥ ﻭﺩﻤﺠﻪ ﻓﻲ ﻤﺠﺎل ﺍﻻﺴﻤﺎﺀ ﺍﻟﺤـﺎﻟﻲ ﺒﺤﻴـﺙ‬ ‫ﻴﻤﻜﻨﻙ ﺍﻟﻭﺼﻭل ﺍﻟﻰ ﺠﻤﻴﻊ ﻋﻨﺎﺼﺭﻩ ﺩﻭﻥ ﺍﻟﺤﺎﺠﺔ ﻟﻼﻟﺘﺯﺍﻡ ﺒﺎﻟﺼﻴﻐﺔ ﺍﻟﻜﺎﻤﻠﺔ ﻻﺴﻡ ﺍﻟﻤﺠﺎل، ﻓﺎﻟﺸﻴﻔﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ:‬ ‫‪Dim X As Devices.OutPuts.Printer‬‬ ‫‪Dim Y As Devices.OutPuts.Screen‬‬ ‫‪Dim Z As Devices.Inputs.Keyboard‬‬ ‫ﻴﻤﻜﻨﻙ ﺍﺨﺘﺼﺎﺭﻩ ﺒﺎﺴﺘﻴﺭﺍﺩ ﺍﻟﻤﺠﺎل ‪ Devices‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﻟﻤﺤﺠﻭﺯﺓ ‪:Imports‬‬ ‫‪Imports MyNameSpace.Devices‬‬ ‫…‬ ‫…‬ ‫‪Dim X As OutPuts.Printer‬‬ ‫‪Dim Y As OutPuts.Screen‬‬ ‫‪Dim Z As Inputs.Keyboard‬‬ ‫ﺒل ﺘﺴﺘﻁﻴﻊ ﺍﺨﺘﺼﺎﺭﻩ ﺍﻜﺜﺭ ﻤﻥ ﺫﻟﻙ ﺍﻴﻀﺎ ﺒﺎﺴﺘﻴﺭﺍﺩ ﺍﻟﻤﺠﺎﻻﺕ ﺍﻟﻔﺭﻋﻴﺔ:‬ ‫‪Imports MyNameSpace.Devices.OutPuts‬‬ ‫‪Imports MyNameSpace.Devices.Inputs‬‬ ‫…‬ ‫…‬ ‫‪Dim X As Printer‬‬ ‫‪Dim Y As Screen‬‬ ‫‪Dim Z As Keyboard‬‬ ‫ﻣﻼﺣﻈﺔ‬ ‫ﻋﻨﺪ اﺳﺘﻴﺮاد ﻣﺠﺎل اﺳـﻤﺎء ﺑﺎﺳـﺘﺨﺪام ‪ ، Imports‬ﻻﺑـﺪ ﻣـﻦ آﺘﺎﺑـﺔ اﻻﺳـﻢ‬ ‫اﻟﻜﺎﻣﻞ ﻟﻤﺠﺎل اﻻﺳﻤﺎء )ﺑﻤﺎ ﻓﻲ ذﻟﻚ اﺳﻢ ﻣﺠﺎل اﻻﺳﻤﺎء اﻟﺬي ﻳﺤﺘ ﻀﻨﻪ(.‬ ‫ﻓﻔﻲ اﻟﺸﻴﻔﺮات اﻟﺴﺎﺑﻘﺔ، اﺳﺘﺨﺪﻣﻨﺎ ﻣﺠـﺎل اﻻﺳـﻤﺎء اﻟﺠـﺬري ﻟﻠﻤﺸـﺮوع‬ ‫‪ My NameSpace‬ﻓﻲ آﻞ ﻣﺮة اﺳﺘﻮردﻧﺎ ﻓﻴﻬﺎ ﻣﺠﺎل اﺳﻤﺎء.‬
  • 99.
    ‫اﻟﻔﺼﻞ اﻟﺜﺎ ﻧﻲ:ﻟﻐﺔ ا ﻟﺒﺮﻣﺠ ﺔ‬ ‫37‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﻗﺩ ﺘﻔﺘﺢ ﺸﺭﻜﺔ ﺍﺴﺘﻴﺭﺍﺩ ﻭﺘﺼﺩﻴﺭ ﻓﻲ ﺍﺤﺩ ﺍﻻﻴﺎﻡ، ﻭﺘﺤﺎﻭل ﺍﺴـﺘﻴﺭﺍﺩ ﺠﻤﻴـﻊ ﻤﺠـﺎﻻﺕ ﺍﻻﺴـﻤﺎﺀ ﻓـﻲ‬ ‫ﺒﺭﺍﻤﺠﻙ، ﻭﻟﻜﻨﻙ ﺴﺘﺼﺎﺏ ﺒﺨﻴﺒﺔ ﺍﻤل ﻜﺒﻴﺭﺓ ﺍﻥ ﺤﺩﺙ ﺘﻌﺎﺭﻀﺎﺕ، ﻓﻠﻭ ﺤﺎﻭﻟﺕ ﺍﺴﺘﻴﺭﺍﺩ ﻫﺫﻴﻥ ﺍﻟﻤﺠﺎﻟﻴﻥ:‬ ‫‪Imports MyNameSpace.Animals‬‬ ‫‪Imports MyNameSpace.Devices.Inputs‬‬ ‫‪Dim X As Mouse‬‬ ‫ﺴﻴﻅﻬﺭ ﻟﻙ ﺍﻟﻤﺘﺭﺠﻡ ﺭﺴﺎﻟﺔ ﺨﻁﺄ ﺒﺴﺒﺏ ﺘﻌﺎﺭﺽ ﺍﺴﻡ ﺍﻟﺘﺭﻜﻴﺏ ‪ Mouse‬ﻓﻲ ﻜﻼ ﺍﻟﻤﺠـﺎﻟﻴﻥ. ﻭﺍﻥ ﻜـﺎﻥ ﻫـﺫﺍ‬ ‫ﺴﻴﺴﺒﺏ ﺨﺴﺎﺭﺓ ﻟﺸﺭﻜﺔ ﺍﻻﺴﺘﻴﺭﺍﺩ ﻭﺍﻟﺘﺼﺩﻴﺭ ﺍﻟﺨﺎﺼﺔ ﺒﻙ، ﻓﻴﻤﻜﻨﻙ ﺍﻻﻟﺘﻔﺎﻑ ﺤﻭل ﻫـﺫﺍ ﺍﻟﺘﻌـﺎﺭﺽ ﺒﺘﻌﺭﻴـﻑ‬ ‫ﻤﺠﺎل ﺍﺴﻤﺎﺀ ﻤﺅﻗﺕ:‬ ‫‪Imports MyNameSpace.Animals‬‬ ‫‪Imports tmp = MyNameSpace.Devices.Inputs‬‬ ‫‪Dim X As Mouse‬‬ ‫‪Dim Y As tmp.Mouse‬‬ ‫ﺍﺨﻴﺭﺍ، ﺍﻥ ﺍﺭﺩﺕ ﺍﺴﺘﻴﺭﺍﺩ ﻤﺠﺎﻻﺕ ﺍﺴـﻤﺎﺀ ﻟﻤﺸـﺎﺭﻴﻊ ﻭﺒـﺭﺍﻤﺞ ﺍﺨـﺭﻯ )ﻜﻤﻜﺘﺒـﺔ ﻓﺌـﺎﺕ‬ ‫‪.NET‬‬ ‫‪ (Framework‬ﻋﻠﻴﻙ ﺍﻀﺎﻓﺔ ﻤﺭﺠﻊ ﻟﻬﺫﻩ ﺍﻟﻤﺠﺎﻻﺕ ﻓﻲ ﺨﺎﻨﺔ ﺍﻟﻤﺭﺍﺠﻊ ﻤـﻥ ﻨﺎﻓـﺫﺓ ﻤﺴﺘﻜﺸـﻑ ﺍﻟﻤﺸـﺭﻭﻉ‬ ‫‪) Solution Explorer‬ﺸﻜل 2 -6(.‬ ‫ﺸﻜل 2 -6: ﺍﺩﺭﺍﺝ ﻤﺭﺍﺠﻊ ﺍﻀﺎﻓﻴﺔ ﻟﻤﺠﺎﻻﺕ ﺍﺴﻤﺎﺀ ﺍﺨﺭﻯ ﻓﻲ ﺍﻟﻤﺸﺭﻭﻉ ﺍﻟﺤﺎﻟﻲ.‬ ‫اﺳﺘﻴﺮاد ﻣﺠﺎل اﺳﻤﺎء دون اﺳﺘﺨﺪام ‪Imports‬‬ ‫ﻁﺭﻴﻘﺔ ﻏﻴﺭ ﺒﺭﻤﺠﻴﺔ ﺍﺨﺭﻯ ﺘﻤﻜﻨﻙ ﻤـﻥ ﺍﺴـﺘﻴﺭﺍﺩ ﻤﺠـﺎﻻﺕ ﺍﺴـﻤﺎﺀ )ﺍﻱ ﺩﻭﻥ ﺍﻟﺤﺎﺠـﺔ ﻻﺴـﺘﺨﺩﺍﻡ ﻋﺒـﺎﺭﺓ‬ ‫‪ (Imports‬ﻭﺫﻟﻙ ﺒﺎﻀﺎﻓﺔ ﺠﻤﻴﻊ ﻤﺠﺎﻻﺕ ﺍﻻﺴﻤﺎﺀ ﺍﻟﺘﻲ ﺘﻭﺩ ﺍﺴﺘﻴﺭﺍﺩﻫﺎ ﻓـﻲ ﺒﺭﻨﺎﻤﺠـﻙ ﻋـﻥ ﻁﺭﻴـﻕ ﺨﺎﻨـﺔ‬ ‫ﺍﻟﺘﺒﻭﻴﺏ ‪ Imports‬ﻓـﻲ ﺼـﻨﺩﻭﻕ ﺍﻟﺤـﻭﺍﺭ ‪) Project Property Pages‬ﺸـﻜل 2 -7 ﻓـﻲ ﺍﻟﺼـﻔﺤﺔ‬ ‫ﺍﻟﻤﻘﺎﺒﻠﺔ(.‬
  • 100.
    ‫47‬ ‫اﻟﺠﺰء اﻷول: اﻻﺳﺎﺳﻴﺎت‬ ‫ــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــــ ــــــــــــــــــــــــــــــــ ـــــــــــــــــــــــــــــــ‬ ‫ﺸﻜل 2 -7: ﺍﺴﺘﻴﺭﺍﺩ ﻤﺠﺎل ﺍﺴﻤﺎﺀ ﺩﻭﻥ ﺍﺴﺘﺨﺩﺍﻡ ‪.Imports‬‬ ‫ﻜﺎﻥ ﻫﺫﺍ ﺍﻟﻔﺼل ﻨﻬﺎﻴﺔ ﺍﻟﺒﺩﺍﻴﺔ ﻻﺘﻘﺎﻥ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠـﺔ ‪ .Visual Basic .NET‬ﺘﺒﻘـﻰ ﻟﻨـﺎ ﻤﺠﻤﻭﻋـﺔ ﻤـﻥ‬ ‫ـﻔﺎﺕ ‪،Attributes‬‬ ‫ـﺎﺕ ‪ ،Interfaces‬ﺍﻟﻤﻭﺍﺼـ‬ ‫ـﺔ ‪ ،Inheritance‬ﺍﻟﻭﺍﺠﻬـ‬ ‫ـﺭﻯ ﻜﺎﻟﻭﺭﺍﺜـ‬ ‫ـﻴﻊ ﺍﻻﺨـ‬ ‫ﺍﻟﻤﻭﺍﻀـ‬ ‫ﻭﺍﻟﺘﻔﻭﻴﺽ ‪ Delegates‬ﻟﻨﻜﻤل ﻤﺭﺤﻠﺔ ﺘﻌﻠﻡ ﺍﻻﺴﺎﺴﻴﺔ. ﻭﻟﻜﻥ ﻗﺒل ﺫﻟﻙ، ﻤـﻥ ﺍﻟﻤﻬـﻡ ﺠـﺩﺍ ﺍﺴـﺘﻴﻌﺎﺏ ﻓﻜـﺭﺓ‬ ‫ﺍﻟﻔﺌﺎﺕ ﻭﺍﻟﻜﺎﺌﻨﺎﺕ ﻋﻨﻭﺍﻥ ﺍﻟﻔﺼل ﺍﻟﺘﺎﻟﻲ.‬