مقدمة عامة عن بيئة الدوت نت

‫اﻋﺪاد ﺧﺎﻟﺪ اﻟﺠﺪﻳﻊ ‪kal_judaia@hotmail.
com‬‬
‫ﻤﻘﺩﻤﺔ ﻋﺎﻤﺔ ﻋﻥ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‬
‫ﺃﻭﻻ ‪ :‬ﺍﻟﺒﻴﺌﺔ ﺍﻟﻤﺘﺼﻠﺔ‬
‫ﺍﻟﺒﻴﺌﺔ ﺍﻟﻤﺘﺼﻠﺔ ﻫﻲ ﺍﻟﺒﻴﺌﺔ ﺍﻟﺘﻲ ﻴﻜﻭﻥ ﻓﻴﻬﺎ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻤﺘﺼﻼ ﺒﺎﺴﺘﻤﺭﺍﺭ‬ ‫• ﺘﻌﺭﻴﻔﻬﺎ ‪:‬‬
‫ﺒﻤﺼﺩﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻁﻭﺍل ﻓﺘﺭﺓ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫• ﺃﻤﺜﻠﺔ ﻋﻠﻴﻬﺎ ‪ :‬ﺃﺤﺩ ﺍﻷﻤﺜﻠﺔ ﻫﻲ ﺃﻥ ﻴﻜﻭﻥ ﻫﻨﺎﻙ ﻨﻅﺎﻡ ﺸﺅﻭﻥ ﻤﻭﻅﻔﻴﻥ ﻴﻜﻭﻥ ﻓﻴﻪ ﺍﻟﻤﺴﺘﻔﻴﺩ‬
‫ﻋﻠﻰ ﺍﺘﺼﺎل ﻤﺒﺎﺸﺭ ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪.‬‬
‫• ﻓﻭﺍﺌﺩﻫﺎ ‪:‬‬
‫‪ -١‬ﺘﺤﻜﻡ ﺃﻗﻭﻯ ﺒﺎﻟﻌﻤل ﺍﻟﺠﻤﺎﻋﻲ ‪ :‬ﻷﻥ ﺍﻟﻤﺴﺘﻔﻴﺩ ﻓﻲ ﺍﻟﺒﻴﺌﺔ ﺍﻟﻤﺘﺼﻠﺔ ﺤﻴﻥ ﻴﻘﻭﻡ ﺒﺘﺤﺩﻴﺙ‬
‫ﺒﻴﺎﻨﺎﺕ ﻓﺈﻨﻪ ﻴﺘﻡ ﺇﻏﻼﻕ ﻋﻤﻠﻴﺔ ﺍﻟﺘﺤﺩﻴﺙ ﻟﻬﺫﻩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺤﺘﻰ ﻴﻨﺘﻬﻲ ﻫﺫﺍ ﺍﻟﻤﺴﺘﻔﻴﺩ ﻤﻥ ﺘﺤﺩﻴﺙ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ‬
‫ﺘﺘﻡ ﻋﻤﻠﻴﺔ ﺇﻏﻼﻕ ﺍﻟﺘﺤﺩﻴﺙ ﻟﻠﻤﺴﺘﻔﻴﺩﻴﻥ ﺍﻵﺨﺭﻴﻥ ﻟﻜﻴﻼ ﻴﺤﺩﺙ ﺘﻌﺎﺭﺽ ﻓﻲ ﺘﺤﺩﻴﺙ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫ﻋﻤﻠﻴﺔ ﺇﻏﻼﻕ ﺍﻟﺴﺠﻼﺕ ﻫﻲ ﻋﻤﻠﻴﺔ ﻴﺴﺘﻁﻴﻊ ﻤﺩﻴﺭ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺃﻭ ﺍﻟﻤﻁﻭﺭ ﺍﻟﺘﺤﻜﻡ ﺒﻬﺎ ﻓﻘﺩ‬
‫ﻴﻜﻭﻥ ﺇﻏﻼﻕ ﺍﻟﺴﺠﻼﺕ ﻋﻠﻰ ﻤﺴﺘﻭﻯ ﺍﻟﺼﻑ ﺃﻭ ﻋﻠﻰ ﻤﺴﺘﻭﻯ ﺍﻟﺠﺩﻭل ﺃﻭ ﻗﺩ ﻴﻜﻭﻥ ﻋﻨﺩ ﺘﺤﺭﻴﺭ‬
‫ﺍﻟﺤﻘﻭل ﺃﻭ ﻋﻨﺩ ﺘﺤﺩﻴﺜﻬﺎ ﻓﻘﻁ ‪.‬‬
‫‪ -٢‬ﺤﺩﺍﺜﺔ ﺃﻜﺜﺭ ﻓﻲ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ :‬ﻭﺫﻟﻙ ﺃﻨﻙ ﺤﻴﻥ ﺘﺴﺘﺭﺠﻊ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﺈﻥ ﻫﺫﻩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻫﻲ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻷﺨﻴﺭﺓ ﻤﺎ ﻟﻡ ﻴﻜﻥ ﻫﻨﺎﻙ ﺘﺤﺩﻴﺙ ﻟﻬﺎ ﻓﻲ ﻓﺘﺭﺓ ﺍﻻﺴﺘﺭﺠﺎﻉ‪ ،‬ﻤﻊ ﺍﻟﻌﻠﻡ ﺃﻨﻪ ﻴﻤﻜﻥ ﻤﻨﻊ‬
‫ﺍﻻﺴﺘﺭﺠﺎﻉ ﺃﺜﻨﺎﺀ ﻓﺘﺭﺓ ﺍﻟﺘﺤﺩﻴﺙ ﻭﻫﻭ ﻤﺎ ﺴﻴﺘﻡ ﺸﺭﺤﻪ ﻻﺤﻘﺎ‪.‬‬
‫• ﻋﻴﻭﺒﻬﺎ ‪:‬‬
‫‪ -١‬ﻭﺠﻭﺏ ﻭﺠﻭﺩ ﺸﺒﻜﺔ ﺍﺘﺼﺎل ﺩﺍﺌﻡ ‪ :‬ﻨﻅﺭﺍ ﻷﻥ ﻗﻨﺎﺓ ﺍﻻﺘﺼﺎل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻔﺘﻭﺤﺔ‬
‫ﻓﻼ ﺒﺩ ﻤﻥ ﻭﺠﻭﺩ ﺸﺒﻜﺔ ﺍﺘﺼﺎل ﺩﺍﺌﻤﺔ ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻫﻭ ﻤﺎ ﻻ ﻴﺘﻭﻓﺭ ﻓﻲ ﻜل ﺍﻷﺤﻴﺎﻥ‪.‬‬
‫‪ -٢‬ﻀﻌﻑ ﻓﻲ ﺍﻟﺘﻭﺴﻊ ﻭ ﺍﻻﻤﺘﺩﺍﺩ ‪ :‬ﻜل ﻤﺴﺘﺨﺩﻡ ﻓﻲ ﺍﻟﺒﻴﺌﺔ ﺍﻟﻤﺘﺼﻠﺔ ﻟﻪ ﺍﺘﺼﺎل ﻤﻊ ﻗﻭﺍﻋﺩ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ‪ ،‬ﻻ ﻴﻤﻜﻥ ﻷﻱ ﻤﺴﺘﺨﺩﻤﻴﻥ ﺃﻥ ﻴﺸﺘﺭﻜﺎ ﻓﻲ ﻨﻔﺱ ﺍﻻﺘﺼﺎل ﻤﻤﺎ ﻴﻌﻨﻲ ﺃﻨﻪ ﻤﻊ ﺯﻴﺎﺩﺓ ﻋﺩﺩ‬
‫ﺍﻟﻤﺴﺘﻔﻴﺩﻴـﻥ ﻴﺠﺏ ﻋﻠﻴﻨﺎ ﺯﻴﺎﺩﺓ ﺍﻻﺘﺼﺎﻻﺕ ﻁﺭﺩﺍ ﻭﻫﻭ ﻤﺎ ﻴﺠﻌل ﺍﻟﻌﻤﻠﻴﺔ ﺸﺒﻪ ﻤﺴﺘﺤﻴﻠﺔ ﻟﺤﺎﻟﺔ ﻤﺜل‬
‫ﻤﻭﻗﻊ ﻋﻠﻰ ﺍﻻﻨﺘﺭﻨﺕ ﻴﺭﺘﺎﺩﻩ ﻤﺌﺎﺕ ﺍﻷﻟﻭﻑ ﻜل ﻴﻭﻡ‪.‬‬
‫‪2‬‬
‫اﻋﺪاد ﺧﺎﻟﺪ اﻟﺠﺪﻳﻊ ‪kal_judaia@hotmail.com‬‬
‫ﺜﺎﻨﻴﺎ ‪ :‬ﺍﻟﺒﻴﺌﺔ ﺍﻟﻤﻨﻔﺼﻠﺔ‬
‫• ﺘﻌﺭﻴﻔﻬﺎ ‪ :‬ﻴﻤﻜﻥ ﺘﻌﺭﻴﻑ ﻫﺫﻩ ﺍﻟﺒﻴﺌﺔ ﺒﺄﻨﻬﺎ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻴﺘﻡ ﻨﺴﺨﻬﺎ ﻤﻥ‬
‫ﻤﺼﺩﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﺘﻌﺩﻴﻠﻬﺎ ﺒﻌﻴﺩﺍ ﻋﻥ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻤﻥ ﺜﻡ ﺇﺭﺠﺎﻉ ﻫﺫﻩ ﺍﻟﺘﻌﺩﻴﻼﺕ‬
‫ﺇﻟﻰ ﻤﺼﺩﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻓﻲ ﻫﺫﻩ ﺍﻟﺒﻴﺌﺔ ﻻ ﺘﻭﺠﺩ ﻗﻨﺎﺓ ﺍﺘﺼﺎل ﻤﻔﺘﻭﺤﺔ ﻤﻊ ﻗﻭﺍﻋﺩ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫• ﺃﻤﺜﻠﺔ ﻋﻠﻴﻬﺎ ‪ :‬ﺍﻟﻤﻭﺍﻗﻊ ﺍﻟﺘﺠﺎﺭﻴﺔ ﻓﻲ ﺍﻻﻨﺘﺭﻨﺕ ﻤﺜل ﻤﻭﻗﻊ ﻴﺒﻴﻊ ﻤﻨﺘﺠﺎﺕ ﻤﺎ ﻓﺈﻨﻙ‬
‫ﻋﻨﺩ ﺘﺼﻔﺢ ﺃﺤﺩ ﺍﻟﻤﻨﺘﺠﺎﺕ ﻻ ﺘﻘﻭﻡ ﺒﺈﻏﻼﻕ ﻋﻤﻠﻴﺔ ﺍﻟﺸﺭﺍﺀ ﻋﻥ ﺃﻱ ﻤﺘﺼﻔﺢ ﺁﺨﺭ‪ ،‬ﻟﺫﺍ‬
‫ﻓﻘﺩ ﻴﺘﻡ ﺸﺭﺍﺀ ﺍﻟﻤﻨﺘﺞ ﺍﻟﺫﻱ ﺘﻘﻭﻡ ﺒﺘﺼﻔﺤﻪ ﻤﻥ ﻗﺒل ﻤﺘﺼﻔﺢ ﺁﺨﺭ‪.‬‬
‫• ﻓﻭﺍﺌﺩﻫﺎ ‪ :‬ﻴﻤﻜﻥ ﺫﻜﺭ ﻓﺎﺌﺩﺘﻴﻥ ﻟﻠﺒﻴﺌﺔ ﺍﻟﻤﺘﺼﻠﺔ ﻭﻫﻤﺎ ‪:‬‬
‫‪ -١‬ﺇﻤﻜﺎﻨﻴﺔ ﺍﺸﺘﺭﺍﻙ ﺃﻜﺜﺭ ﻤﻥ ﻤﺴﺘﺨﺩﻡ ﺒﻨﻔﺱ ﺍﻻﺘﺼﺎل ‪ :‬ﻨﻅﺭﺍ ﻷﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻴﻘﻭﻡ ﺒﺎﻻﺘﺼﺎل ﺜﻡ‬
‫ﻨﺴﺦ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺜﻡ ﻗﻁﻊ ﺍﻻﺘﺼﺎل ﻓﺈﻥ ﻓﺘﺭﺓ ﻭﺠﻭﺩ ﺍﻻﺘﺼﺎل ﻤﻊ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻓﺘﺭﺓ ﻀﺌﻴﻠﺔ ﺠﺩﺍ‪ ،‬ﻟﺫﺍ‬
‫ﻴﻤﻜﻥ ﺃﻥ ﻴﺴﺘﻔﻴﺩ ﻤﺴﺘﺨﺩﻡ ﺁﺨﺭ ﻤﻥ ﻨﻔﺱ ﺍﻻﺘﺼﺎل ﺒﻌﺩ ﺃﻥ ﻴﻨﺘﻬﻲ ﻤﻨﻪ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺍﻷﻭل‪.‬‬
‫‪ -٢‬ﺃﺩﺍﺀ ﻋﺎﻟﻲ ﻭ ﻗﺎﺒل ﻟﻠﺘﻭﺴﻊ ﺒﺸﻜل ﻜﺒﻴﺭ ﻤﻘﺎﺭﻨﺔ ﺒﺎﻟﺒﻴﺌﺔ ﺍﻟﻤﺘﺼﻠﺔ ‪ :‬ﻨﻅﺭﺍ ﻷﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻻ‬
‫ﻴﺤﺠﺯ ﺍﻻﺘﺼﺎل ﻓﺈﻥ ﻋﺩﺩ ﺍﻟﻤﺴﺘﺨﺩﻤﻴﻥ ﺤﻴﻥ ﻴﺯﻴﺩ ﻓﺈﻨﻨﺎ ﻗﺩ ﻨﺴﺘﺨﺩﻡ ﺒﻌﺽ ﺍﻟﺘﻘﻨﻴﺎﺕ ﻤﺜل ﺘﻘﻨﻴﺔ‬
‫ﺃﺤﻭﺍﺽ ﺍﻻﺘﺼﺎل – ﺴﻴﺄﺘﻲ ﻟﻬﺎ ﺍﻟﻜﻼﻡ ﻓﻲ ﻓﺼل ﺍﻻﺘﺼﺎل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ -‬ﻭﻫﻭ ﻤﺎ ﻴﻭﻓﺭ ﺃﻋﺩﺍﺩﺍ‬
‫ﻜﺒﻴﺭﺓ ﻤﻥ ﺍﻻﺘﺼﺎﻻﺕ‪.‬‬
‫• ﻋﻴﻭﺒﻬﺎ ‪:‬‬
‫‪ -١‬ﻋﺩﻡ ﺤﺩﺍﺜﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ :‬ﻟﻭ ﺭﺠﻌﻨﺎ ﺇﻟﻰ ﻤﺜﺎل ﺍﻟﻤﺘﺼﻔﺢ ﺍﻟﺫﻱ ﻴﺭﻴﺩ ﺸﺭﺍﺀ‬
‫ﻤﻨﺘﺞ ﻤﻥ ﺍﻻﻨﺘﺭﻨﺕ ﻟﻭﺠﺩﻨﺎ ﺃﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﺘﻭﺠﺩ ﻋﻨﺩﻩ ﻏﻴﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺤﻘﻴﻘﺔ‪،‬‬
‫ﺒﻤﻌﻨﻰ ﺃﻥ ﺭﺼﻴﺩ ﺍﻟﻜﺘﺏ ﻤﺜﻼ ﺍﻟﻤﻭﺠﻭﺩ ﺃﻤﺎﻤﻪ ﻏﻴﺭ ﺍﻟﺭﺼﻴﺩ ﺍﻟﺤﻘﻴﻘﻲ ﻷﻨﻪ ﻗﺩ ﻗﺎﻡ ﻋﺩﺓ‬
‫ﻤﺘﺼﻔﺤﻴﻥ ﺒﺸﺭﺍﺀ ﻨﻔﺱ ﺍﻟﻜﺘﺎﺏ ﺃﺜﻨﺎﺀ ﺘﺼﻔﺤﻪ ﻟﻪ‪.‬‬
‫‪ -٢‬ﺇﻤﻜﺎﻨﻴﺔ ﺤﺩﻭﺙ ﺘﻀﺎﺭﺏ ﻋﻨﺩ ﺘﺤﺩﻴﺙ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻫﻭ ﻤﺎ ﻴﺘﻁﻠﺏ ﺤل ﻫﺫﺍ‬
‫ﺍﻟﺘﻀﺎﺭﺏ ‪ :‬ﻭﻫﻭ ﻤﺎ ﻴﺘﻀﺢ ﺒﺎﻟﻤﺜﺎل ﻓﻠﻭ ﺍﻓﺘﺭﻀﻨﺎ ﺃﻥ ﻫﻨﺎﻙ ﺒﺭﻨﺎﻤﺠﺎ ﻟﺸﺅﻭﻥ‬
‫ﺍﻟﻤﻭﻅﻔﻴﻥ ﻭ ﺃﻨﺎ ﺃﻗﻭﻡ ﺒﺘﺤﺩﻴﺙ ﻋﻤﺭ ﺍﻟﻤﻭﻅﻑ ﻭ ﺼﺎﺩﻑ ﺃﻥ ﻜﺎﻥ ﻫﻨﺎﻙ ﻤﻭﻅﻑ‬
‫‪3‬‬
‫ﻏﻴﺭﻱ ﻴﻘﻭﻡ ﺒﺘﺤﺩﻴﺙ ﺒﻴﺎﻥ ﺍﻟﻌﻤﺭ ﻟﻨﻔﺱ ﺍﻟﻤﻭﻅﻑ ﻓﺈﻥ ﻫﺫﺍ ﺍﻟﺸﻲﺀ ﺴﻭﻑ ﻴﺤﺩﺙ‬
‫ﺘﻀﺎﺭﺒﺎ ﻓﻲ ﺍﻟﺘﺤﺩﻴﺙ ﻴﺘﻁﻠﺏ ﺤﻼ ﻭﻫﻭ ﻤﺎ ﺴﺘﻌﺭﻑ ﻜﻴﻑ ﺘﻘﻭﻡ ﺒﻪ‪.‬‬
‫ﻨﻅﺭﺍ ﻷﻥ ﺍﻟﺒﻴﺌﺔ ﻏﻴﺭ ﻤﺘﺼﻠﺔ ﻓﻼ ﻴﻭﺠﺩ ﺃﻱ ﻗﻔل ﻋﻠﻰ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ ،‬ﻟﺫﺍ‬
‫ﻓﺎﻟﺘﻀﺎﺭﺏ ﻭﺍﺭﺩ ﺒﺸﻜل ﻜﺒﻴﺭ‪.‬‬
‫ﻨﻤﺎﺫﺝ ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪:‬‬

‫ﻴﻭﺠﺩ ﺃﺭﺒﻌﺔ ﻨﻤﺎﺫﺝ ﺃﺴﺎﺴﻴﺔ ﻟﻠﻭﺼﻭل ﺇﻟﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ ،‬ﻫﺫﻩ ﺍﻟﻨﻤﺎﺫﺝ ﻻ ﺘﻌﺘﻤﺩ ﻋﻠﻰ ﺒﻴﺌﺔ ﺃﻭ ﻟﻐﺔ‬
‫ﻤﻌﻴﻨﺔ ﺇﻨﻤﺎ ﻫﻲ ﻨﻤﺎﺫﺝ ﻋﺎﻤﺔ‪.‬‬
‫‪ .A‬ﻨﻤﻭﺫﺝ ﺍﻟﻁﺒﻘﺔ ﺍﻟﻭﺍﺤﺩﺓ ‪:‬‬
‫‪ -١‬ﻤﺜﺎل ﻋﻠﻴﻪ ‪ :‬ﻴﻤﻜﻥ ﺘﻤﺜﻴل ﻫﺫﺍ ﺍﻟﻨﻤﻭﺫﺝ ﺒﻤﺴﺘﻔﻴﺩ ﻴﻌﻤل ﻋﻠﻰ ﺠﻬﺎﺯ ﻭﺍﺤﺩ ﻓﻴﻪ ﺒﺭﻨﺎﻤﺞ‬
‫ﻴﺤﻭﻱ ﻜل ﺃﺠﺯﺍﺀ ﺍﻟﻨﻅﺎﻡ‪.‬‬
‫‪-٢‬ﻤﺯﺍﻴﺎﻩ ‪ :‬ﻨﻅﺭﺍ ﻷﻥ ﻜل ﺸﻲﺀ ﻓﻲ ﻨﻔﺱ ﺍﻟﻤﻜﺎﻥ ﻻ ﺘﻭﺠﺩ ﺃﻱ ﺼﻌﻭﺒﺎﺕ ﻓﻲ ﺍﻟﻭﺼﻭل‬
‫ﺇﻟﻰ ﻜل ﺠﺯﺀ ﻤﻥ ﺃﺠﺯﺍﺀ ﺍﻟﻨﻅﺎﻡ‪.‬‬
‫‪-٣‬ﺍﻟﻌﻴﻭﺏ ‪ :‬ﻋﻨﺩ ﺘﻌﺩﻴل ﺃﻱ ﺠﺯﺀ ﻤﻥ ﺍﻟﻨﻅﺎﻡ ﻴﺠﺏ ﺇﻋﺎﺩﺓ ﺘﻭﺯﻴﻊ ﺍﻟﺘﻌﺩﻴﻼﺕ ﻋﻠﻰ ﻜل‬
‫ﻤﺴﺘﻔﻴﺩ‪.‬‬
‫ﻭﻟﻌﻠﻨﺎ ﻋﻨﺩ ﺫﻜﺭ ﻁﺒﻘﺎﺕ ﺍﻟﻨﻅﺎﻡ ﻨﻌﻁﻲ ﺘﻘﺴﻴﻤﺎ ﺃﻭﻟﻴﺎ ﻟﺜﻼﺙ ﻁﺒﻘﺎﺕ ﺸﻬﻴﺭﺓ ‪:‬‬
‫ﺍﻟﺸﺭﺡ‬ ‫ﺍﻟﻁﺒﻘﺔ‬
‫ﺘﺤﻭﻱ ﻫﺫﻩ ﺍﻟﻁﺒﻘﺔ ﻭﺍﺠﻬﺔ ﺍﻟﻤﺴﺘﻔﻴﺩ ﻤﺜل ﺃﺯﺭﺍﺭ ﺍﻷﻤﺭ ﻭ ﻤﺭﺒﻌﺎﺕ ﺍﻟﻨﺹ‬ ‫ﻁﺒﻘﺔ ﻭﺍﺠﻬﺔ ﺍﻟﻤﺴﺘﻔﻴﺩ‬
‫ﻭﻗﺩ ﺘﺤﺘﻭﻱ ﻫﺫﻩ ﺍﻟﻁﺒﻘﺎﺕ ﻋﻠﻰ ﺒﻌﺽ ﺍﻟﺘﺩﻗﻴﻘﺎﺕ ﺍﻟﺘﻲ ﻻ ﺘﺤﺘﺎﺝ ﺍﻟﻭﺼﻭل‬
‫ﺇﻟﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﺜل ﺘﺩﻗﻴﻕ ﺃﻗﺼﻰ ﻁﻭل ﻟﺤﻘل ﻤﺎ ﺃﻭ ﺘﺩﻗﻴﻕ ﺃﻥ ﺘﺎﺭﻴﺦ‬
‫ﺍﻟﻤﻴﻼﺩ ﻴﻤﺜل ﺘﺎﺭﻴﺨﺎ ﺼﺤﻴﺤﺎ‪.‬‬
‫ﺘﺤﺘﻭﻱ ﻫﺫﻩ ﺍﻟﻁﺒﻘﺔ ﺍﻟﻭﻅﺎﺌﻑ ﺍﻟﺘﻲ ﺘﻁﺒﻕ ﻗﻭﺍﻋﺩ ﺍﻟﻌﻤل ﻤﺜل ﺍﻟﻭﻅﻴﻔﺔ ﺍﻟﺘﻲ‬ ‫ﻁﺒﻘﺔ ﻗﻭﺍﻋﺩ ﺍﻟﻌﻤل‬
‫ﺘﺩﻗﻕ ﺍﺴﺘﺤﻘﺎﻕ ﻤﻭﻅﻑ ﻤﺎ ﻹﺠﺎﺯﺓ ﻤﻥ ﻋﺩﻤﻪ‪.‬‬
‫ﻫﺫﻩ ﺍﻟﻁﺒﻘﺔ ﻫﻲ ﺍﻟﺘﻲ ﺘﻘﻭﻡ ﺒﺎﻻﺘﺼﺎل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﻋﻤل ﺍﻟﺘﺤﺩﻴﺜﺎﺕ‬ ‫ﻁﺒﻘﺔ ﺍﻟﻭﺼﻭل ﻟﻠﺒﻴﺎﻨﺎﺕ‬
‫ﻋﻠﻴﻬﺎ‪.‬‬
‫‪4‬‬
‫‪ .B‬ﻨﻤﻭﺫﺝ ﺍﻟﻁﺒﻘﺘﻴﻥ‬
‫• ﻓﻜﺭﺓ ﺍﻟﻨﻤﻭﺫﺝ ‪ :‬ﻓﻜﺭﺓ ﻫﺫﺍ ﺍﻟﻨﻤﻭﺫﺝ ﺘﺘﻤﺜل ﻓﻲ ﺃﺤﺩ ﺍﻟﺨﻴﺎﺭﺍﺕ ﺍﻟﺜﻼﺜﺔ ‪:‬‬
‫‪ .I‬ﺇﻤﺎ ﺍﺠﺘﻤﺎﻉ ﻁﺒﻘﺔ ﻭﺍﺠﻬﺔ ﺍﻟﻤﺴﺘﻔﻴﺩ ﻭ ﻁﺒﻘﺔ ﻗﻭﺍﻋﺩ ﺍﻟﻌﻤل ﻤﻊ ﺒﻌﻀﻴﻬﻤﺎ ﻭﻤﻥ ﺜﻡ‬
‫ﺘﻜﻭﻥ ﺍﻟﻁﺒﻘﺔ ﺍﻟﺜﺎﻨﻴﺔ ﻫﻲ ﻁﺒﻘﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪ .II‬ﺃﻭ ﺍﺠﺘﻤﺎﻉ ﻁﺒﻘﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻊ ﻁﺒﻘﺔ ﻗﻭﺍﻋﺩ ﺍﻟﻌﻤل‪.‬‬
‫‪ .III‬ﺃﻭ ﺘﻭﺯﻴﻊ ﻁﺒﻘﺔ ﻗﻭﺍﻋﺩ ﺍﻟﻌﻤل ﺒﻴﻥ ﻁﺒﻘﺔ ﻭﺍﺠﻬﺔ ﺍﻟﻤﺴﺘﻔﻴﺩ ﻭ ﻁﺒﻘﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫•‬
‫ﻤﺜﺎﻟﻪ ‪ :‬ﻤﻥ ﺃﻤﺜﻠﺔ ﻫﺫﺍ ﺍﻟﻨﻤﻭﺫﺝ ﻤﺎ ﻴﺴﻤﻰ ﺒﺎﻟﺨﺎﺩﻡ‪/‬ﺍﻟﻤﺴﺘﻔﻴﺩ‪.‬‬
‫• ﺍﻟﻤﺯﺍﻴﺎ ‪ :‬ﻴﻤﻜﻥ ﺍﻟﻘﻭل ﺒﺄﻥ ﺃﺒﺭﺯ ﻤﻤﻴﺯﺍﺕ ﻫﺫﺍ ﺍﻟﻨﻤﻭﺫﺝ ﻫﻲ ﺍﻟﻔﺼل ﺍﻟﺠﺯﺌﻲ ﻟﻭﻅﺎﺌﻑ‬
‫ﺍﻟﻨﻅﺎﻡ‪.‬‬
‫ﺍﻟﻌﻴﻭﺏ ‪:‬‬ ‫•‬

‫‪ -١‬ﺼﻌﻭﺒﺔ ﺍﻟﺘﻭﺴﻊ ﺍﻟﻤﺴﺘﻘﺒﻠﻲ ﻟﻠﺨﻠﻁ ﺒﻴﻥ ﻁﺒﻘﺘﻲ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﻭﺍﺠﻬﺔ ﺍﻟﻤﺴﺘﻔﻴﺩ ﻭﻫﻭ‬
‫ﻤﺎ ﻴﺴﻤﻰ ﺒﺎﻟﻤﺴﺘﺨﺩﻡ ﺍﻟﻤﺘﻀﺨﻡ ”‪.“Fat Client‬‬
‫‪ -٢‬ﺼﻌﻭﺒﺔ ﺍﻟﺼﻴﺎﻨﺔ ﺍﻟﻤﺴﺘﻘﺒﻠﻴﺔ ﻭﺫﻟﻙ ﻋﻨﺩ ﺘﻌﺩﻴل ﺃﻱ ﺠﺯﺀ ﻤﻥ ﺃﺠﺯﺍﺀ ﺍﻟﻨﻅﺎﻡ ﻓﺈﻥ ﺫﻟﻙ‬
‫ﻴﺘﻁﻠﺏ ﺇﻋﺎﺩﺓ ﺘﻭﺯﻴﻊ ﺍﻟﻨﻅﺎﻡ ﻋﻠﻰ ﻜل ﺍﻟﻤﺴﺘﺨﺩﻤﻴﻥ ﻭﻫﻭ ﻤﺎ ﻴﻜﻭﻥ ﻤﻜﻠﻔﺎ ﻋﻨﺩﻤﺎ ﻴﻜﺜﺭ‬
‫ﻋﺩﺩ ﺍﻟﻤﺴﺘﺨﺩﻤﻴﻥ‪.‬‬
‫‪ -٣‬ﺍﺨﺘﻼﻁ ﺃﺠﺯﺍﺀ ﺍﻟﻨﻅﺎﻡ ﺒﻌﻀﻬﺎ ﺒﺒﻌﺽ ﻤﻤﺎ ﻴﻌﻨﻲ ﺼﻌﻭﺒﺔ ﺇﺠﺭﺍﺀ ﺘﻌﺩﻴﻼﺕ ﻋﻠﻰ ﺍﻟﻨﻅﺎﻡ‬
‫ﻟﺘﺒﻌﺜﺭ ﻗﻭﺍﻋﺩ ﺍﻟﻌﻤل ﻓﻲ ﺃﻤﺎﻜﻥ ﻤﺨﺘﻠﻔﺔ‪.‬‬
‫‪.C‬ﻨﻤﻭﺫﺝ ﺍﻟﻁﺒﻘﺎﺕ ﺍﻟﺜﻼﺙ ‪:‬‬
‫ﻓﻜﺭﺓ ﺍﻟﻨﻤﻭﺫﺝ ‪ :‬ﻴﻤﻜﻥ ﺘﻤﺜﻴل ﻫﺫﺍ ﺍﻟﻨﻤﻭﺫﺝ ﺒﺄﻨﻪ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺫﻱ ﻴﻨﻘﺴﻡ ﺇﻟﻰ ﺜﻼﺙ‬ ‫•‬
‫ﻁﺒﻘﺎﺕ ﻭﻫﻲ ‪ :‬ﻁﺒﻘﺔ ﻭﺍﺠﻬﺔ ﺍﻟﻤﺴﺘﻔﻴﺩ ‪ ،‬ﻁﺒﻘﺔ ﻗﻭﺍﻋﺩ ﺍﻟﻌﻤل‪،‬‬
‫ﻁﺒﻘﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪. (١-١‬‬
‫‪5‬‬
‫ﺍﻟﻤﺯﺍﻴﺎ ‪ :‬ﺴﻬﻭﻟﺔ ﺍﻟﺼﻴﺎﻨﺔ ﻭﻟﻭ ﻜﺎﻨﺕ ﻭﺍﺠﻬﺔ ﺍﻟﻤﺴﺘﻔﻴﺩ ‪ Web‬ﻟﻜﺎﻨﺕ ﺘﻜﻠﻔﺔ ﺼﻴﺎﻨﺔ‬ ‫•‬
‫ﺃﺠﻬﺯﺓ ﺍﻟﻤﺴﺘﻔﻴﺩ = ﺼﻔﺭ‪.‬‬
‫ﺍﻟﻌﻴﻭﺏ ‪ :‬ﻗﺩ ﺘﺒﺭﺯ ﺘﻜﺎﻟﻴﻑ ﺠﺩﻴﺩﺓ ﻤﺜل ﺘﻜﺎﻟﻴﻑ ﺨﺎﺩﻡ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬ ‫•‬
‫ﺸﻜل ‪ : ١ -١‬ﻨﻤﻭﺫﺝ ﺍﻟﻁﺒﻘﺎﺕ ﺍﻟﺜﻼﺙ‬
‫ﻟﻤﺴﺘﻔﻴﺪ‬‫واﺟﻬﺔوﻟﺠﻬﺔ ا‬
‫اﻟﻤﺴﺘﻔﻴﺪ‬ ‫ﻃﺒﻘﺔ ﻃﺒﻘﺔ‬
‫ﻃﺒﻘﺔ ﻗﻮاﻋﺪ اﻟﻌﻤﻞ‬ ‫ﻃﺒﻘﺔ اﻟﺒﻴﺎﻧﺎت‬
‫‪ .D‬ﻨﻤﻭﺫﺝ ﺍﻟﻁﺒﻘﺎﺕ ﺍﻟﻤﺘﻌﺩﺩﺓ‬

‫• ﻓﻜﺭﺓ ﺍﻟﻨﻤﻭﺫﺝ ‪ :‬ﻴﻤﻜﻥ ﺘﻤﺜﻴل ﻫﺫﺍ ﺍﻟﻨﻤﻭﺫﺝ ﺒﺄﻜﺜﺭ ﻤﻥ ﺜﻼﺙ ﻁﺒﻘﺎﺕ ﺤﺴﺏ ﺍﺤﺘﻴﺎﺝ ﻜل‬
‫ﻤﻨﺸﺄﺓ ﻴﻤﻜﻥ ﺃﻥ ﻴﻜﻭﻥ ﻫﻨﺎﻙ ﻁﺒﻘﺔ ﺭﺍﺒﻌﺔ ﻤﺜل ﻁﺒﻘﺔ ﻟﻠﺘﻌﺎﻤل ﻤﻊ ﺍﻷﻤﻥ ﻭ ﺇﻋﻁﺎﺀ‬
‫ﺘﺼﺎﺭﻴﺢ ﺍﻟﺩﺨﻭل ﻟﻠﻨﻅﺎﻡ ﻭﻏﻴﺭ ﺫﻟﻙ ﺤﺴﺏ ﺍﻟﺤﺎﺠﺔ‪.‬‬
‫ﺍﻟﻤﺯﺍﻴﺎ ‪:‬‬ ‫•‬
‫ﺘﺠﻌل ﻤﻥ ﺍﻟﺴﻬﻭﻟﺔ ﺍﻻﻤﺘﺩﺍﺩ ﻭ ﺍﺘﺼﺎل ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﻋﻠﻰ ﺃﻨﻅﻤﺔ ﺘﺸﻐﻴل ﻤﺨﺘﻠﻔﺔ‪.‬‬
‫• ﺍﻟﻌﻴﻭﺏ ‪:‬‬
‫‪ -١‬ﻋﻴﻭﺏ ﺃﻤﻨﻴﺔ ﻻﺘﺼﺎل ﻋﺩﺓ ﺃﺠﻬﺯﺓ ﺒﺒﻌﻀﻬﺎ ﺍﻟﺒﻌﺽ‪.‬‬
‫‪ -٢‬ﺼﻌﻭﺒﺔ ﺍﻟﺘﻁﻭﻴﺭ ﻭ ﺍﻟﺘﻨﻔﻴﺫ ﻭﺫﻟﻙ ﻻﺯﺩﻴﺎﺩ ﻋﺩﺩ ﺍﻟﻁﺒﻘﺎﺕ ﻭﻫﻭ ﻤﺎ ﻴﻨﺸﺊ ﺘﻌﻘﻴﺩﺍ ﻓﻲ ﺍﻟﺘﻁﻭﻴﺭ ﻭ‬
‫ﺍﻟﺘﻨﻔﻴﺫ‪.‬‬
‫‪6‬‬
kal_judaia@hotmail.com ‫اﻋﺪاد ﺧﺎﻟﺪ اﻟﺠﺪﻳﻊ‬
‫ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‬
: ‫ﻴﻤﻜﻥ ﺘﻘﺴﻴﻤﻬﺎ ﺇﻟﻰ ﺜﻼﺜﺔ ﻋﻨﺎﺼﺭ‬

.(٢-١) ‫( ﺍﻨﻅﺭ ﺍﻟﺸﻜل‬CLR, FCL, ASP, WinForms) ‫ ﺇﻁﺎﺭ ﺍﻟﻌﻤل ﻭ ﻴﺸﻤل‬-١
.vs.net,office،win.net ‫ ﻤﻨﺘﺠﺎﺕ ﻤﺜل‬-٢
.‫ ﺨﺩﻤﺎﺕ ﻤﻨﺘﺠﺔ ﻤﻥ ﻗﺒل ﺃﻱ ﺠﻬﺔ‬-٣
‫ ﺇﻁﺎﺭ ﺍﻟﻌﻤل‬-١
‫ﻴﻌﺘﺒﺭ ﺇﻁﺎﺭ ﺍﻟﻌﻤل ﻗﻠﺏ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻟﺫﻟﻙ ﻻﺒﺩ ﻤﻥ ﺘﻬﻴﺌﺔ ﺇﻁﺎﺭ ﺍﻟﻌﻤل ﻓﻲ ﺃﻱ ﺠﻬﺎﺯ ﺴﻭﻑ‬
‫ ﻴﻤﻜﻥ ﺇﻨﺯﺍل ﺇﻁﺎﺭ ﺍﻟﻌﻤل ﻤﺠﺎﻨﺎ ﻤﻥ ﻤﻭﻗﻊ‬.‫ﻴﻌﻤل ﻋﻠﻴﻪ ﺘﻁﺒﻴﻕ ﺼﻤﻡ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‬
: ‫ ﻴﻤﻜﻥ ﺘﻘﺴﻴﻡ ﺇﻁﺎﺭ ﺍﻟﻌﻤل ﺇﻟﻰ ﻗﺴﻤﻴﻥ ﺃﺴﺎﺴﻴﻴﻥ ﻫﻤﺎ‬.‫ﻤﺎﻴﻜﺭﻭﺴﻭﻓﺕ‬
Common Language Runtime ‫ ﺍﻟﺘﺸﻐﻴل ﺍﻟﻤﺸﺘﺭﻙ ﻟﻠﻐﺎﺕ‬.I
Common Language Specification ‫ ﺍﻟﻤﻭﺍﺼﻔﺎﺕ ﺍﻟﻤﺸﺘﺭﻜﺔ ﻟﻠﻐﺎﺕ‬.II
‫ ﺇﻁﺎﺭ ﺍﻟﻌﻤل ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‬: ٢-١ ‫ﺸﻜل‬
ASP.NET
ASP.NET WindowsForms
Windows Forms
Web Services Web Forms Controls Drawing
The.NET
The .NETClass
ClassLibrary
Library
ADO.NET IO XML Threading Security
CommonLanguage
Common LanguageRuntime
Runtime
Type System Metadata Execution
WindowsAPI
Windows API COM+Services
COM+ Services
7
‫‪ .I‬ﺍﻟﺘﺸﻐﻴل ﺍﻟﻤﺸﺘﺭﻙ ﻟﻠﻐﺎﺕ )‪(CLR‬‬

‫ﻴﻤﺜل ﺃﺤﺩ ﺍﻷﺠﺯﺍﺀ ﺍﻷﺴﺎﺴﻴﺔ ﻟﻨﻁﺎﻕ ﺍﻟﻌﻤل ﻓﻲ ﺍﻟﺩﻭﺕ ﻨﺕ ﻭﻴﻤﻜﻥ ﻭﺼﻔﻪ ﺒﺄﻨﻪ ﻤﻜﻴﻨﺔ ﺘﻨﻔﻴﺫ ﺍﻟﻜﻭﺩ‬
‫ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﻜﻭﻨﻪ ﻴﻘﺩﻡ ﺨﺩﻤﺎﺕ ﺘﺠﻌل ﺍﻟﺘﻁﻭﻴﺭ ﺃﺴﻬل‪ .‬ﻫﺫﻩ ﺍﻟﺨﺩﻤﺎﺕ ﻤﺘﻭﻓﺭﺓ ﻷﻱ ﻟﻐﺔ ﺘﻁﻭﺭ‬
‫ﺒﻨﺎﺀ ﻋﻠﻰ ﺍﻟﻤﻭﺍﺼﻔﺎﺕ ﺍﻟﻤﺸﺘﺭﻜﺔ ﻟﻠﻐﺎﺕ ‪ CLS‬ﻭﻫﻭ ﻤﺎ ﻴﻌﻨﻲ ﺃﻥ ‪ CLR‬ﻴﺴﺘﻁﻴﻊ ﺍﺴﺘﻀﺎﻓﺔ ﻟﻐﺎﺕ‬
‫ﻤﻨﻬﺎ‬ ‫‪CLR‬‬ ‫ﺇﻟﻰ‬ ‫ﻟﻐﺔ‬ ‫ﻋﺸﺭﻴﻥ‬ ‫ﻤﻥ‬ ‫ﺃﻜﺜﺭ‬ ‫ﺇﻀﺎﻓﺔ‬ ‫ﺘﻡ‬ ‫ﻭﻗﺩ‬ ‫ﺍﻟﻤﺨﺘﻠﻔﺔ‪.‬‬ ‫ﺍﻟﺒﺭﻤﺠﺔ‬
‫‪ VB,C#,C++,Delphi,COBOL‬ﻭﻴﺠﺭﻱ ﺘﻁﻭﻴﺭ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﻠﻐﺎﺕ ﻟﺘﻀﺎﻑ ﺇﻟﻰ ‪CLR‬‬
‫ﻭﻫﻭ ﻤﺎ ﻴﺠﻌل ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﺒﻴﺌﺔ ﻏﻴﺭ ﻤﻌﺘﻤﺩﺓ ﻋﻠﻰ ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﻤﺎ‪.‬‬
‫ﻴﻘﺩﻡ ﻋﺩﺩ ﻜﺒﻴﺭ ﻤﻥ ﺍﻟﻔﻭﺍﺌﺩ ﻟﻠﻤﻁﻭﺭﻴﻥ ﻤﻨﻬﺎ ‪:‬‬
‫‪ (١‬ﺍﻷﻤﻥ‪.‬‬
‫‪ (٢‬ﻤﺘﺎﺒﻌﺔ ﺍﻟﻜﻭﺩ –‪ : – Debugging‬ﺘﺴﺘﻁﻴﻊ ﺍﻟﻘﻔﺯ ﺃﺜﻨﺎﺀ ﺍﻟﻤﺘﺎﺒﻌﺔ ﻤﻥ ﻜﻭﺩ ﺇﻟﻰ ﺁﺨﺭ ﺤﺘﻰ‬
‫ﻟﻭ ﻜﺎﻨﺎ ﻤﻜﺘﻭﺒﺎﻥ ﺒﻠﻐﺎﺕ ﻤﺨﺘﻠﻔﺔ‪.‬‬
‫‪ (٣‬ﺩﻋﻡ ﺃﻗﻭﻯ ﻟﻺﺼﺩﺍﺭﺍﺕ ﺍﻟﻤﺘﻌﺩﺩﺓ ﻭﻫﻭ ﻤﺎ ﺃﻨﻬﻰ ﻤﺸﻜﻠﺔ ﻤﺎ ﻴﺴﻤﻰ ﺒــ ‪.DLL Hell‬‬
‫‪ (٤‬ﺇﺩﺍﺭﺓ ﺍﻟﺫﺍﻜﺭﺓ ﻭ ﺘﺠﻤﻴﻊ ﺍﻟﻨﻔﺎﻴﺎﺕ ‪.‬‬
‫‪ (٥‬ﺇﺩﺍﺭﺓ ‪.Thread‬‬
‫‪ .II‬ﺍﻟﻤﻭﺍﺼﻔﺎﺕ ﺍﻟﻤﺸﺘﺭﻜﺔ ﻟﻠﻐﺎﺕ ‪CLS‬‬

‫ﻴﻌﺭﻑ ‪ CLS‬ﻤﻌﻴﺎﺭﺍ ﻗﻴﺎﺴﻴﺎ ﻷﻨﻭﺍﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﺠﻤﻴﻊ ﻟﻐﺎﺕ ‪ CLR‬ﻭﻫﻭ ﻤﺎﻴﻌﻨﻲ ﺃﻥ ﻜل ﻟﻐﺎﺕ‬
‫‪ CLS‬ﺴﻭﻑ ﻴﻜﻭﻥ ﻟﻬﺎ ﻨﻔﺱ ﺍﻟﺤﺠﻡ ﻟﻸﻨﻭﺍﻉ ﺍﻟﺼﺤﻴﺤﺔ ﻭ ﺍﻟﻁﻭﻴﻠﺔ –‪-Integers,Long‬‬
‫ﻫﺫﺍ ﺍﻟﻤﻌﻴﺎﺭ ﻴﻌﻨﻲ ﺘﻌﺎﻭﻨﺎ ﺃﻜﺜﺭ ﺒﻴﻥ ﺍﻟﻠﻐﺎﺕ ‪ ،‬ﺴﻭﻑ ﻴﻜﻭﻥ ﺒﺈﻤﻜﺎﻨﻙ ﺇﺭﺴﺎل ﻤﺭﺠﻊ ﺇﻟﻰ ﻓﺌﺔ ﻤﻥ‬
‫ﻜﺎﺌﻥ ﺇﻟﻰ ﺁﺨﺭ ﺤﺘﻰ ﻟﻭ ﻜﺎﻨﺎ ﻤﻜﺘﻭﺒﻴﻥ ﺒﻠﻐﺎﺕ ﻤﺨﺘﻠﻔﺔ‪ .‬ﻜل ﻟﻐﺔ ﻻ ﺘﻁﺒﻕ ﻫﺫﻩ ﺍﻟﻤﻌﺎﻴﻴﺭ ﻟﻥ ﺘﺴﺘﻔﻴﺩ‬
‫ﻤﻥ ﺍﻟﺨﺩﻤﺎﺕ ﺍﻟﺘﻲ ﺘﻘﺩﻡ ﻤﻥ ﻗﺒل ‪ .CLR‬ﻴﻤﻜﻥ ﺘﻠﺨﻴﺹ ﻫﺫﻩ ﺍﻟﻤﻭﺍﺼﻔﺎﺕ ﺒﺎﻟﻨﻘﺎﻁ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ -١‬ﺃﻨﻭﺍﻉ ﺒﻴﺎﻨﺎﺕ ﻗﻴﺎﺴﻴﺔ‪.‬‬
‫‪ -٢‬ﻤﺼﻔﻭﻓﺎﺕ ﻗﻴﺎﺴﻴﺔ – ﻜل ﻓﻬﺎﺭﺱ ﺍﻟﻤﺼﻔﻭﻓﺎﺕ ﻻﺒﺩ ﺃﻥ ﻴﺒﺩﺃ ﻤﻥ ﺼﻔﺭ‪.-‬‬
‫‪ -٣‬ﻤﻌﺎﻟﺠﺔ ﻫﻴﻜﻠﻴﺔ ﻟﻸﺨﻁﺎﺀ‪.‬‬
‫‪ -٤‬ﻁﺭﻕ ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﺍﻷﻨﻅﻤﺔ ﺍﻟﺘﻁﺒﻴﻘﻴﺔ ﺍﻟﺨﺎﺼﺔ ﺒﺈﻁﺎﺭ ﺍﻟﻌﻤل‪.‬‬
‫‪8‬‬
‫ﻤﻊ ﺍﻟﻌﻠﻡ ﺃﻥ ﺍﻟﻠﻐﺎﺕ ﺍﻟﻤﺴﺘﻀﺎﻓﺔ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻟﻬﺎ ﺍﻟﺤﻕ ﻓﻲ ﺯﻴﺎﺩﺓ ﻤﻤﻴﺯﺍﺕ ﺃﺨﺭﻯ ﻟﻜﻥ ﻫﺫﻩ‬
‫ﺍﻟﻤﻤﻴﺯﺍﺕ ﻟﻥ ﺘﺴﺘﻁﻴﻊ ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﻜﺎﺌﻨﺎﺕ ﺍﻟﺩﻭﺕ ﻨﺕ‪.‬‬
‫ﺍﻟﻜﻭﺩ ﺍﻟﻤﺩﺍﺭ ﻭ ﺍﻟﻜﻭﺩ ﻏﻴﺭ ﺍﻟﻤﺩﺍﺭ‬
‫ﺍﻟﻜﻭﺩ ﺍﻟﻤﻁﻭﺭ ﺒﻠﻐﺔ ﻤﻭﺍﻓﻘﺔ ﻟــ ‪ CLS‬ﻴﺴﻤﻰ ﻜﻭﺩ ﻤﺩﺍﺭ ‪–Managed Code‬‬
‫ﺃﻤﺎ ﺍﻟﻜﻭﺩ ﺍﻟﺫﻱ ﻴﻌﺘﻤﺩ ﻋﻠﻰ ﺘﻘﻨﻴﺔ ‪ COM‬ﺃﻭ ‪ WIN32 API‬ﻴﺴﻤﻰ ﻜﻭﺩ ﻏﻴﺭ ﻤﺩﺍﺭ‬
‫ﻟﺫﺍ ﻴﻤﻜﻥ ﺍﻟﻘﻭل ﺒﺄﻥ ﻓﻴﺠﻭﺍل ﺒﻴﺴﻙ ‪ ٦‬ﻜﻭﺩ ﻏﻴﺭ ﻤﺩﺍﺭ ﺒﻨﺴﺒﺔ ﻤﺎﺌﺔ ﺒﺎﻟﻤﺎﺌﺔ ﻭ ﻋﻠﻰ ﺍﻟﻨﻘﻴﺽ ﻤﻨﻪ‬
‫ﻟﺫﺍ ﻴﻤﻜﻥ ﺍﻟﻘﻭل ﺒﺄﻥ ﺍﻟﻜﻭﺩ ﻏﻴﺭ‬ ‫ﺍﻟﻜﻭﺩ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻫﻭ ﻜﻭﺩ ﻤﺩﺍﺭ ﺒﻨﺴﺒﺔ ﻤﺎﺌﺔ ﺒﺎﻟﻤﺎﺌﺔ‪.‬‬
‫ﺍﻟﻤﺩﺍﺭ ﻟﻥ ﻴﺴﺘﻔﻴﺩ ﻤﻥ ﺍﻟﺨﺩﻤﺎﺕ ﺍﻟﻤﻘﺩﻤﺔ ﻤﻥ ﻗﺒل ‪.CLR‬‬
‫ﺍﻟﻠﻐﺔ ﺍﻟﻭﺴﻁﻴﺔ ﻟﻤﻴﻜﺭﻭﺴﻭﻓﺕ‬

‫‪MSIL‬‬
‫ﻋﻨﺩﻤﺎ ﺘﻘﻭﻡ ﺒﺈﻨﺘﺎﺝ ﺍﻟﻜﻭﺩ –‪ -Compile‬ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻓﺈﻨﻪ ﻻ ﻴﺘﻡ ﺘﺄﻟﻴﻔﻪ ﺇﻟﻰ ﻜﻭﺩ ﺃﻭﻟﻲ –‬
‫‪ . -Native code‬ﻴﻘﻭﻡ ﻤﺅﻟﻑ ﺍﻟﺩﻭﺕ ﻨﺕ ﺒﺈﻨﺸﺎﺀ ﻤﻠﻑ ﻴﺤﻭﻱ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫‪ .a‬ﻟﻐﺔ ﻭﺴﻁﻴﺔ ‪.IL‬‬
‫‪ .b‬ﺒﻴﺎﻨﺎﺕ ﻭﺍﺼﻔﺔ ‪ :Metadata‬ﻭﺘﺤﻭﻱ ﻤﻌﻠﻭﻤﺎﺕ ﻤﺜل ‪:‬‬
‫‪ -١‬ﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ ﺠﻤﻴﻊ ﺍﻷﻨﻭﺍﻉ ﺍﻟﺘﻲ ﺍﺴﺘﺨﺩﻤﺘﻬﺎ‪.‬‬
‫‪ -٢‬ﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ ﻜل ﺃﻨﻭﺍﻉ ﺍﻟﺩﻭﺍل‪.‬‬
‫‪ -٣‬ﺍﻟﺩﻭﺍل ﺍﻟﺘﻲ ﺘﻭﺠﺩ ﻟﻬﺎ ﻤﺭﺠﻌﻴﺔ ﻓﻲ ﻜﻭﺩﻙ‪.‬‬
‫ﻭﻏﻴﺭﻫﺎ ﻤﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﻴﺤﺘﺎﺠﻬﺎ ‪ CLR‬ﻓﻲ ﺍﻟﺒﻴﺌﺔ ﺍﻟﺘﺸﻐﻴﻠﻴﺔ ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪(٣-١‬‬
‫‪9‬‬
‫ﺷﻜﻞ ‪ : ٣ -١‬أﺳﻠﻮب إﻧﺘﺎج اﻟﻜﻮد ﻓﻲ ﺑﻴﺌﺔ اﻟﺪوت ﻧﺖ‬

‫ﺍﻻﻨﺘﺎﺝ‬
‫‪Source‬‬ ‫‪Language‬‬ ‫)‪Code (IL‬‬
‫‪Assembly‬‬
‫‪Code‬‬ ‫‪Compiler‬‬ ‫‪Metadata‬‬
‫‪Native‬‬ ‫‪JIT‬‬
‫‪Code‬‬ ‫‪Compiler‬‬ ‫ﻋﻨﺩ ﺍﺴﺘﺩﻋﺎﺀ ﺍﻟﻨﻅﺎﻡ ﻷﻭل ﻤﺭﺓ‬
‫ﺍﻟﺘﻨﻔﻴﺫ‬
‫• ﻨﻅﺭﺍ ﻷﻥ ﺍﻟﻤﻠﻑ ﺍﻟﻤﺅﻟﻑ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﺍﻟﺸﻴﺌﻴﻥ ﺍﻟﺴﺎﺒﻘﻴﻥ ﻓﺈﻨﻪ ﻴﻌﺘﺒﺭ ﻤﻠﻔﺎ‬
‫ﻤﻭﻀﺤﺎ ﻟﻤﺤﺘﻭﺍﻩ ﻟﺫﺍ ﻓﻼ ﻴﻭﺠﺩ ﺃﻱ ﺤﺎﺠﺔ ﺒﻌﺩ ﺍﻟﻴﻭﻡ ﻟﻤﻜﺘﺒﺎﺕ ﺍﻷﻨﻭﺍﻉ ‪ Type Library‬ﻭﻻ‬
‫ﺇﻟﻰ ﻤﻠﻔﺎﺕ ‪ IDL‬ﻜﻤﺎ ﻻ ﺘﻭﺠﺩ ﺤﺎﺠﺔ ﻟﺘﻌﺭﻴﻔﺎﺕ ﻓﻲ ﺍﻟﺭﻴﺠﺴﺘﺭﻱ‪.‬‬
‫ﺍﻟﻤﺅﻟﻑ ﻓﻲ ﺍﻟﻭﻗﺕ ﺍﻟﻤﺤﺩﺩ ‪JIT‬‬

‫ﺒﺎﻟﻁﺒﻊ ﻓﺈﻥ ﻤﻠﻑ ‪ IL‬ﻻ ﻴﺩﻭﻡ ﻜﻤﺎ ﻫﻭ ﻷﻥ ‪ IL‬ﻴﻌﺘﺒﺭ ﻤﻠﻑ ﻴﻌﺘﻤﺩ ﻋﻠﻰ ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ﻓﺈﻨﻪ ﻋﻨﺩ‬
‫ﺘﺸﻐﻴل ﻫﺫﺍ ﺍﻟﻤﻠﻑ ﻴﺘﻡ ﺘﺄﻟﻴﻔﻪ ﺇﻟﻰ ﻜﻭﺩ ﺃﻭﻟﻲ‪ .‬ﺘﺘﻡ ﻋﻤﻠﻴﺔ ﺍﻟﺘﺄﻟﻴﻑ ﺒﻭﺍﺴﻁﺔ ﺃﺩﺍﺓ ﻤﻥ ﺃﺩﻭﺍﺕ ﻨﻁﺎﻕ‬
‫ﺍﻟﻌﻤل ﺘﺴﻤﻰ ﺍﻟﻤﺅﻟﻑ ﻓﻲ ﺍﻟﻭﻗﺕ ﺍﻟﻤﺤﺩﺩ ﺍﻨﻅﺭ ﺍﻟﺸﻜل ﺍﻟﺴﺎﺒﻕ‪.‬‬
‫ﺃﺴﻤﺎﺀ ﺍﻻﻤﺘﺩﺍﺩﺍﺕ ‪NameSpaces‬‬

‫ﻴﻘﺴﻡ ﺇﻁﺎﺭ ﺍﻟﻌﻤل ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﺍﻟﻭﻅﺎﺌﻑ ﺇﻟﻰ ﺍﻤﺘﺩﺍﺩﺍﺕ ﻤﻨﻁﻘﻴﺔ‪ .‬ﺍﻟﻬﺩﻑ ﻤﻥ ﻫﺫﺍ ﺍﻟﺘﻘﺴﻴﻡ ﻫﻭ‬
‫ﺘﺭﺘﻴﺏ ﻭﺘﻨﻅﻴﻡ ﺍﻟﻭﻅﺎﺌﻑ ‪ ،‬ﻫﺫﻩ ﺍﻻﻤﺘﺩﺍﺩﺍﺕ ﻤﻭﺯﻋﻪ ﻋﻠﻰ ﺃﺸﻜﺎل ﻫﺭﻤﻴﻪ ﺘﺴﻤﻰ ‪ NameSpaces‬ﺃﻭ‬
‫ﺠﻤ‪‬ﻊ ﻓﻲ ﺍﻟﻤﺠﻤﻭﻋﺔ‬
‫ﺕ ﹸﺘ ‪‬‬
‫ل ﺍﻟﻭﻅﺎﺌﻑ ﺍﻟﺘﻲ ﺘﻌﻤل ﻤﻊ ﻨﻅﺎﻡ ﺍﻟﻤﻠﻔﺎ ﹼ‬
‫ﺃﺴﻤﺎﺀ ﺍﻻﻤﺘﺩﺍﺩﺍﺕ‪ .‬ﻋﻠﻰ ﺴﺒﻴل ﺍﻟﻤﺜﺎل‪ ،‬ﻜ ّ‬
‫)‪.(System.IO‬‬
‫‪10‬‬
‫ﻁﺭﻕ ﺇﻀﺎﻓﺔ ﻤﺭﺠﻊ ﺇﻟﻰ ﻓﻀﺎﺀﺍﺕ ﺍﻷﺴﻤﺎﺀ‬

‫ﻴﻭﺠﺩ ﻫﻨﺎﻙ ﻁﺭﻴﻘﺘﺎﻥ ﺃﺴﺎﺴﻴﺘﺎﻥ ﻹﻀﺎﻓﺔ ﻤﺭﺠﻊ ﺇﻟﻰ ﻓﻀﺎﺀﺍﺕ ﺍﻷﺴﻤﺎﺀ ﻤﺎ ﻭﻫﻤﺎ ‪:‬‬
‫‪ -١‬ﺇﻀﺎﻓﺔ ﻋﺒﺎﺭﺓ ‪ Imports‬ﻤﻥ ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ ﻤﺒﺎﺸﺭﺓ‪ :‬ﻋﻨﺩﻤﺎ ﺘﻘﻭﻡ ﺒﺈﻀﺎﻓﺔ ﻤﺭﺠﻊ ﺇﻟﻰ ﻓﻀﺎﺀﺍﺕ‬
‫ﺃﺴﻤﺎﺀ ﻤﺎ ﻋﻥ ﻁﺭﻴﻕ ﻋﺒﺎﺭﺓ ‪ Imports‬ﻓﺈﻨﻙ ﺘﺴﺘﻁﻴﻊ ﺍﺴﺘﺨﺩﺍﻡ ﻜل ﺍﻟﻭﻅﺎﺌﻑ ﻓﻲ ﺫﻟﻙ ﺍﻟﻔﻀﺎﺀ ﺍﻻﺴﻤﻲ‬
‫ﻤﺒﺎﺸﺭﺓ ﻭﺩﻭﻥ ﺍﻟﺤﺎﺠﺔ ﺇﻟﻰ ﻜﺘﺎﺒﺔ ﺍﻻﺴﻡ ﺍﻟﻜﺎﻤل‪ ،‬ﻭ ﻟﻌﻠﻨﺎ ﻨﺄﺨﺫ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ‬
‫ﻤﻥ ﺍﻟﻜﻭﺩ ﺍﻟﺴﺎﺒﻕ ﻨﻼﺤﻅ ﻤﺎ ﻴﻠﻲ – ﺃﺭﺠﻭﺍ ﺃﻥ ﺘﻬﺘﻡ ﺒﺎﻟﻔﻜﺭﺓ ﻭ ﻟﻴﺱ ﺒﺎﻟﻤﺤﺘﻭﻯ‪: -‬‬
‫‪ .I‬ﻓﻲ ﺒﺩﺍﻴﺔ ﺍﻟﻜﻭﺩ ﺃﻀﻔﻨﺎ ﻤﺭﺠﻊ ﺇﻟﻰ ﻓﻀﺎﺀ ﺍﺴﻡ ‪System.Convert‬‬
‫‪ .II‬ﺜﻡ ﻗﻤﻨﺎ ﺒﻤﻜﺎﻥ ﺁﺨﺭ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﺩﺍﻟﺔ ‪ ToInt32‬ﻭ ﺍﻟﺘﻲ ﺘﻨﺘﻤﻲ ﺇﻟﻰ ﻓﻀﺎﺀ ﺍﻻﺴﻡ‬
‫‪ ، System.Convert‬ﻟﺫﻟﻙ ﻗﻤﻨﺎ ﺒﻜﺘﺎﺒﺔ ﺍﺴﻡ ﺍﻟﺩﺍﻟﺔ ﻤﺒﺎﺸﺭﺓ‪.‬‬
‫‪ .III‬ﻟﻭ ﻟﻡ ﻨﻀﻑ ﻤﺭﺠﻊ ﺇﻟﻰ ﻓﻀﺎﺀ ﺍﻻﺴﻡ ‪ System.Convert‬ﻟﻭﺠﺏ ﻋﻠﻴﻙ ﻋﻨﺩ‬
‫ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺩﺍﻟﺔ ‪ ToInt32‬ﺃﻥ ﺘﻜﺘﺏ ﺍﻻﺴﻡ ﻜﺎﻤﻼ ﻭﻫﻭ ‪:‬‬
‫‪System.convert.ToInt32‬‬
‫ﻋﻨﺩ ﺇﻀﺎﻓﺔ ﻤﺭﺠﻊ ﺇﻟﻰ ﻓﻀﺎﺀ ﺍﻻﺴﻡ ﻤﺎ ﻻﺒﺩ ﻤﻥ ﻭﻀﻊ ﺠﻤﻠﺔ ﺍﻻﺴﺘﻴﺭﺍﺩ ﻓﻲ ﺒﺩﺍﻴﺔ ﺍﻟﻜﻭﺩ ﻗﺒل ﺃﻱ‬
‫ﺠﻤﻠﺔ‪.‬‬
‫‪11‬‬
‫‪-٢‬ﻋﻥ ﻁﺭﻴﻕ ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤل ‪ :‬ﺍﺘﺒﻊ ﺍﻟﺨﻁﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻹﻀﺎﻓﺔ ﻤﺭﺠﻊ ﻋﻥ ﻁﺭﻴﻕ‬
‫ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤل ‪:‬‬
‫‪ .I‬ﺍﻨﻘﺭ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻷﻴﻤﻥ ﻋﻠﻰ ﻤﺠﻠﺩ ‪ Refrences‬ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ ﻤﺴﺘﻜﺸﻑ‬
‫ﺍﻟﺤﻠﻭل ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل )‪(٤-١‬‬
‫ﺸﻜل ‪ : ٤ -١‬ﺇﻀﺎﻓﺔ ﻤﺭﺠﻊ‬
‫‪ .II‬ﺍﻨﻘﺭ ﻋﻠﻰ ‪ Add Refrence‬ﻟﻴﻅﻬﺭ ﻟﻙ ﺍﻟﺸﻜل )‪(٥-١‬‬

‫‪ .III‬ﻗﻡ ﺒﺎﺨﺘﻴﺎﺭ ﺍﻟﻤﺭﺠﻊ ﺍﻟﺫﻱ ﺘﺭﻴﺩ‪.‬‬
‫ﺸﻜل ‪ : ٦ -١‬ﺍﺨﺘﻴﺎﺭ ﺍﻟﻤﺭﺠﻊ‬
‫ﺍﻟﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﺒﻌﺽ ﺍﻻﻤﺘﺩﺍﺩﺍﺕ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻭ ﻓﻭﺍﺌﺩﻫﺎ‬

‫ﺍﻟﺸﺭﺡ‬ ‫ﺍﻻﻤﺘﺩﺍﺩ‬
‫‪queues, linked lists, hash‬‬ ‫ﻴﻘﺩﻡ ﺃﻨﻭﺍﻉ ﺍﻟﻤﺠﻤﻭﻋﺎﺕ ﻤﺜل‬ ‫‪System.Collections‬‬
‫‪.sorted lists‬‬
‫ﻴﻘﺩﻡ ﻭﻅﺎﺌﻑ ﻤﻌﺎﻟﺠﺔ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻋﻨﺩ ﺍﻟﻤﺴﺘﻔﻴﺩ‪.‬‬ ‫‪System.Data‬‬
‫ﻟﻠﻭﺼﻭل ﺇﻟﻰ ﺍﻟﻭﻅﺎﺌﻑ ﺍﻟﺨﺎﺼﺔ ﺒﺎﻟﺭﺴﻭﻤﺎﺕ‪.‬‬ ‫‪System.Drawing‬‬
‫ﻤﻌﺎﻟﺠﺔ ﺍﻟﻤﻠﻔﺎﺕ‪.‬‬ ‫‪System.IO‬‬
‫ﻟﻠﻌﻤل ﻤﻊ ﻤﻠﻔﺎﺕ ﺇﻜﺱ ﺇﻡ ﺇل‬ ‫‪System.XML‬‬
‫‪12‬‬
‫ﺧﺎﻟﺪ اﻟﺠﺪﻳﻊ ‪kal_judaia@hotmail.com‬‬
‫ﻤﻘﺩﻤﺔ ﻟﺒﻨﺎﺀ ﺘﻁﺒﻴﻘﺎﺕ ﺍﻟﻭﻨﺩﻭﺯ‬
‫ﻗﺒل ﺃﻥ ﺘﺒﺩﺃ ﺒﺎﻟﺘﻁﻭﻴﺭ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻋﻠﻴﻙ ﺒﺘﻔﺤﺹ ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ‪ .‬ﻨﻌﻨﻲ ﺒﺒﻴﺌﺔ‬
‫ﺍﻟﺘﻁﻭﻴﺭ ﻜل ﻤﺎ ﺘﺘﻌﺎﻤل ﻤﻌﻪ ﺃﺜﻨﺎﺀ ﺘﻁﻭﻴﺭﻙ ﻟﺒﺭﻨﺎﻤﺞ ﻤﺎ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‪ .‬ﻋﻨﺩﻤﺎ ﺘﺸﻐل‬
‫ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻓﺈﻥ ﻜل ﻤﺎ ﺘﺭﺍﻩ ﺃﻤﺎﻤﻙ ﻫﻭ ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ‪ .‬ﺴﻭﻑ ﻨﺤﺎﻭل ﺠﺎﻫﺩﻴﻥ ﻓﻲ ﻫﺫﺍ‬
‫ﺍﻟﻔﺼل ﺃﻥ ﻨﺘﻌﺭﺽ ﻷﻫﻡ ﻤﺎ ﺘﺤﺘﺎﺠﻪ ﺃﺜﻨﺎﺀ ﺘﻁﻭﻴﺭ ﻨﻅﺎﻡ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‪ .‬ﻗﺩ ﻻ ﻨﺸﺭﺡ ﻜل‬
‫ﺸﻲﺀ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ ﻟﻜﻥ ﻟﻥ ﻨﺘﺭﻙ ﺸﻴﺌﺎ ﻤﻬﻤﺎ ﺘﺤﺘﺎﺠﻪ ﺒﺎﺴﺘﻤﺭﺍﺭ ﺇﻻ ﻭ ﺴﻨﺘﻌﺭﺽ ﻟﻪ ﺇﻤﺎ‬
‫ﺒﺎﻟﺘﺼﺭﻴﺢ ﺃﻭ ﺒﺎﻟﺘﻠﻤﻴﺢ‪.‬‬
‫ﻁﺭﻴﻘﺔ ﺍﻟﺩﺨﻭل ﺇﻟﻰ ‪Visual Studio.Net‬‬
‫‪ -١‬ﺍﻨﻘﺭ ﻓﻭﻕ ﺯﺭ ‪ Start‬ﺍﻟﻤﻭﺠﻭﺩ ﻋﻠﻰ ﺸﺭﻴﻁﺎ ﺍﻟﻤﻬﺎﻡ ﻓﻲ ﻨﻅﺎﻡ ﺍﻟﺘﺸﻐﻴل ‪.Windows‬‬
‫‪ -٢‬ﺴﻭﻑ ﺘﻅﻬﺭ ﻟﻙ ﻗﺎﺌﻤﺔ ﺍﺨﺘﺭ ‪.Programs‬‬
‫‪ -٣‬ﺴﻭﻑ ﺘﻅﻬﺭ ﻟﻙ ﻗﺎﺌﻤﺔ ﻓﺭﻋﻴﺔ ﻓﻴﻬﺎ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﺍﻟﺒﺭﺍﻤﺞ‪.‬‬
‫‪ -٤‬ﺍﻨﻘﺭ ﻋﻠﻰ ﺍﻟﻘﺎﺌﻤﺔ ‪Microsoft Visual Studio.Net‬‬
‫‪ -٥‬ﺍﻨﻘﺭ ﻋﻠﻰ ‪ Microsoft Visual Studio‬ﻜﻤﺎ ﻴﻅﻬﺭ ﻓﻲ ﺍﻟﺸﻜل )‪.(١-٢‬‬
‫ﺸﻜل ‪ :١-٢‬ﺘﺸﻐﻴل ﻓﻴﺠﻭﺍل ﺴﺘﻭﺩﻴﻭ ﺩﻭﺕ ﻨﺕ‬
‫‪15‬‬
‫ﺍﻟﺼﻔﺤﺔ ﺍﻷﻭﻟﻰ‬
‫ﺒﻌﺩ ﺍﻟﺩﺨﻭل ﻋﻠﻰ ﺒﺭﻨﺎﻤﺞ ﻓﻴﺠﻭﺍل ﺴﺘﻭﺩﻴﻭ ﺩﻭﺕ ﻨﺕ ﻓﺈﻥ ﺃﻭل ﻤﺎ ﺴﻴﻭﺍﺠﻬﻙ ﻫﻭ ﺍﻟﺼﻔﺤﺔ ﺍﻷﻭﻟﻰ ﻜﻤﺎ‬
‫ﺘﻼﺤﻅ ﻓﻲ ﺍﻟﺸﻜل ‪. ٢-٢‬‬
‫ﺸﻜل ‪ : ٢ -٢‬ﺍﻟﺼﻔﺤﺔ ﺍﻷﻭﻟﻰ ﺒﻌﺩ ﺩﺨﻭل ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ‬
‫ﺘﺘﻜﻭﻥ ﻫﺫﻩ ﺍﻟﺼﻔﺤﺔ ﻤﻥ ﺠﺯﺃﻴﻥ ﻫﻤﺎ ‪:‬‬
‫‪ -١‬ﺍﻟﺠﺯﺀ ﺍﻷﻭﺴﻁ ‪ :‬ﻭﻴﺤﻭﻱ ﻨﻭﻋﻴﻥ ﻤﻥ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻭﻫﻲ ‪:‬‬

‫ﺍﻟﻤﺸﺎﺭﻴﻊ ﺍﻷﺨﻴﺭﺓ ﺍﻟﺘﻲ ﺴﺒﻕ ﻭ ﻋﻤﻠﺕ ﻋﻠﻴﻬﺎ ﻭ ﺘﻨﺩﺭﺝ ﺘﺤﺕ ﺸﺭﻴﻁ ‪ Projects‬ﻜﻤﺎ‬ ‫‪.I‬‬
‫ﺃﻨﻪ ﻴﻤﻜﻨﻙ ﺇﻨﺸﺎﺀ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ﻤﻥ ﻫﻨﺎ ﺃﻭ ﻓﺘﺢ ﻤﺸﺭﻭﻉ ﺴﺎﺒﻕ ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل‬
‫)‪.(٣-٢‬‬
‫ﺸﻜل ‪٣-٢‬‬
‫‪16‬‬
‫‪ .II‬ﺍﻟﺒﺤﺙ ﻓﻲ ﺍﻟﻤﺸﺎﺭﻴﻊ‪ :‬ﻭﻫﻲ ﻁﺭﻴﻘﺔ ﺴﺭﻴﻌﺔ ﻟﻠﺒﺤﺙ ﻋﻥ ﻤﺴﺎﻋﺩﺓ ﻓﻲ ﺠﻤﻴﻊ ﺍﻟﻤﺸﺎﺭﻴﻊ‬

‫ﺍﻟﻤﺘﻭﻓﺭﺓ ﻟﺩﻴﻙ ﻜﻌﻴﻨﺔ ﻤﻥ ﻗﺒل ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺸﻜل )‪.(٤-٢‬‬
‫ﺸﻜل ‪ : ٤ -٢‬ﺍﻟﺒﺤﺙ ﻓﻲ ﺍﻟﻤﺸﺎﺭﻴﻊ‬
‫‪ -٢‬ﺍﻟﺠﺯﺀ ﺍﻷﻴﺴﺭ ‪ :‬ﺘﺴﺘﻁﻴﻊ ﻤﻥ ﺨﻼﻟﻪ ﺯﻴﺎﺭﺓ ﻤﻭﻗﻊ ﻤﻴﻜﺭﻭﺴﻭﻓﺕ ﻭ ﺍﻹﻁﻼﻉ ﻋﻠﻰ ﻤﺠﻤﻭﻋﺎﺕ‬
‫ﺍﻷﺨﺒﺎﺭ ﻭ ﺁﺨﺭ ﺍﻟﺘﺤﺩﻴﺜﺎﺕ ﻭ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﺍﻷﺸﻴﺎﺀ ﺍﻷﺨﺭﻯ‪.‬‬
‫ﺍﻟﻤﻠﻑ ﺍﻟﺸﺨﺼﻲ ‪My Profile‬‬

‫ﻫﻭ ﺃﺤﺩ ﺨﻭﺍﺹ ﺍﻟﺼﻔﺤﺔ ﺍﻷﻭﻟﻰ ﻭ ﻴﻤﻜﻨﻙ ﻤﻥ ﺍﺨﺘﻴﺎﺭ ﺒﻌﺽ ﺍﻹﻋﺩﺍﺩﺍﺕ ﺍﻟﺘﻲ ﺴﻭﻑ ﺘﺴﺘﻤﺭ‬
‫ﻤﻌﻙ ﻓﻲ ﻜل ﺍﻟﻤﺸﺎﺭﻴﻊ ﺍﻟﺘﻲ ﺘﻨﺸﺌﻬﺎ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪.(٥-٢‬‬
‫ﺘﺴﺘﻁﻴﻊ ﻋﻤل ﺃﻴﺎ ﻤﻤﺎ ﻴﻠﻲ ‪:‬‬
‫‪ -١‬ﺘﻐﻴﻴﺭ ﺃﺴﻠﻭﺏ ﻋﺭﺽ ﺍﻟﻨﻤﺎﺫﺝ ﻤﻥ ﺍﻷﺴﻠﻭﺏ ﺍﻟﺤﺩﻴﺙ ﻓﻲ ﺍﻟﺩﻭﺕ ﻨﺕ ﺇﻟﻰ ﺃﺴﻠﻭﺏ ﻋﺭﺽ‬
‫ﺍﻟﻨﻤﺎﺫﺝ ﻓﻲ ﻓﻴﺠﻭﺍل ﺒﻴﺴﻙ ‪ ٦‬ﺇﺫﺍ ﺃﺭﺩﺕ ﺃﻥ ﻻ ﺘﺘﻐﻴﺭ ﻁﺭﻴﻘﺔ ﻋﺭﺽ ﺍﻟﻨﻤﺎﺫﺝ‪.‬‬
‫‪ -٢‬ﺤﺼﺭ ﺍﻟﻤﺴﺎﻋﺩﺓ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻋﻠﻰ ﺨﻴﺎﺭ ﻤﺤﺩﺩ ﻤﺜل ﺃﻥ ﺘﺨﺘﺎﺭ ﺤﺼﺭ ﺍﻟﻤﺴﺎﻋﺩﺓ ﻓﻲ‬
‫ﺍﻟﻤﻭﺍﻀﻴﻊ ﺍﻟﻤﺘﻌﻠﻘﺔ ﺒﻔﻴﺠﻭﺍل ﺒﻴﺴﻙ ﺃﻭ ﺒﺎﻟﻤﻭﺍﻀﻴﻊ ﺍﻟﻤﺘﻌﻠﻘﺔ ﺒﻠﻐﺔ ﺴﻲ ﺸﺎﺭﺏ ﺍﻨﻅﺭ ﺍﻟﺸﻜل‬
‫)‪(٥-٢‬‬
‫‪ -٣‬ﻓﺘﺢ ﺁﺨﺭ ﻤﺸﺭﻭﻉ ﻋﻤﻠﺕ ﻓﻴﻪ ﺁﻟﻴﺎ ﻜﻠﻤﺎ ﻓﺘﺤﺕ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‪.‬‬
‫‪ -٤‬ﻋﺭﺽ ﻤﺭﺒﻊ ﻓﺘﺢ ﻤﺸﺭﻭﻉ ﺃﻭ ﺇﻨﺸﺎﺀ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ﻜﻠﻤﺎ ﻓﺘﺤﺕ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‪.‬‬
‫‪17‬‬
‫ﺸﻜل ‪ : ٥-٢‬ﺍﻟﻤﻠﻑ ﺍﻟﺸﺨﺼﻲ‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﺘﻌﺘﺒﺭ ﺍﻋﺩﺍﺩﺍﺕ ﺍﻟﻤﻠﻑ ﺍﻟﺸﺨﺼﻲ ﻤﻥ ﺍﻻﻋﺩﺍﺩﺍﺕ ﺍﻟﻜﻤﺎﻟﻴﺔ ﺍﻟﺘﻲ ﻗﺩ ﻻ ﺘﺤﺘﺎﺝ ﺃﻥ ﺘﺭﺠﻊ ﻟﻬﺎ‬
‫ﻁﻭﺍل ﻓﺘﺭﺓ ﺍﻟﺘﻁﻭﻴﺭ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‬
‫ﺃﻨﻭﺍﻉ ﺍﻟﻤﺸﺎﺭﻴﻊ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‬

‫ﻗﺒل ﺇﻨﺸﺎﺀ ﺃﻭل ﻤﺸﺭﻭﻉ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻴﺤﺴﻥ ﺒﻨﺎ ﺃﻥ ﻨﺭﺸﺩﻙ ﺇﻟﻰ ﺃﻨﻭﺍﻉ ﺍﻟﻤﺸﺎﺭﻴﻊ ﺍﻟﺘﻲ ﻴﻤﻜﻨﻙ‬
‫ﺒﻨﺎﺌﻬﺎ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‪.‬‬
‫ﺍﻟﺸﺭﺡ‬ ‫ﻨﻭﻉ ﺍﻟﻤﺸﺭﻭﻉ‬
‫‪ WindowsApplication‬ﻴﺴﺘﺨﺩﻡ ﻹﻨﺸﺎﺀ ﺘﻁﺒﻴﻘﺎﺕ‪.‬‬
‫‪ ClassLibrary‬ﻁﺭﻴﻘﺔ ﻹﻨﺸﺎﺀ ﻤﻜﻭﻨﺎﺕ ﺩﻭﺕ ﻨﺕ ﻻﺴﺘﺨﺩﺍﻤﻬﺎ ﻓﻲ ﺘﻁﺒﻴﻘﺎﺕ ﺃﺨﺭﻯ‪.‬‬
‫ﻟﺴﻁﺢ ﺍﻟﻤﻜﺘﺏ ﻤﻊ ﺍﻟﻌﻠﻡ ﺃﻨﺔ ﻻ ﻴﻭﺠﺩ ﻟﻬﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﻭﺍﺠﻬﺔ‬
‫ﻤﺭﺌﻴﺔ ﻴﺘﻌﺎﻤل ﻤﻌﻬﺎ ﺍﻟﻤﺴﺘﺨﺩﻡ‪ .‬ﻴﺤﻭﻱ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ‬
‫ﻭﻅﺎﺌﻑ ﻴﻤﻜﻥ ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﻓﻲ ﺒﺎﻗﻲ ﺃﻨﻭﺍﻉ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ‪.‬‬
‫‪ Windows Control‬ﺘﻁﺒﻴﻘﺎﺕ ﺘﻬﺩﻑ ﻹﻨﺸﺎﺀ ﺃﺩﻭﺍﺕ ﻴﻤﻜﻥ ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﻓﻲ ﺘﻁﺒﻴﻘﺎﺕ ﻭﻨﺩﻭﺯ‪.‬‬
‫‪Library‬‬
‫ﻓﻬل ﻓﻜﺭﺕ ﻴﻭﻤﺎ ﺒﻁﺭﻴﻘﺔ ﺒﻨﺎﺀ ﺃﺩﺍﺓ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺃﻭ ﺃﺩﺍﺓ ﺍﻟﻘﺎﺌﻤﺔ‪ .‬ﻫﺫﺍ‬
‫ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﻴﻤﻜﻨﻙ ﻤﻥ ﺒﻨﺎﺀ ﺃﺩﻭﺍﺕ ﻭﻤﻥ ﺜﻡ ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﻭﻗﺩ‬
‫‪18‬‬
‫ﺘﺘﻤﻜﻥ ﻤﻥ ﺒﻴﻌﻬﺎ ﺇﺫﺍ ﻜﺎﻨﺕ ﺃﺩﺍﺓ ﺫﺍﺕ ﻗﻴﻤﺔ‪.‬‬

‫‪ ASP.NET Web‬ﺘﻁﺒﻴﻘﺎﺕ ‪ Web‬ﻭ ﻫﻲ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﺍﻟﺘﻲ ﺘﻌﻤل ﻤﻥ ﺨﻼل ﺍﻟﻤﺘﺼﻔﺢ‪.‬‬
‫‪Application‬‬
‫ﻭﺃﺼﺒﺢ ﺍﻵﻥ ﻤﻥ ﺍﻟﺴﻬﻭﻟﺔ ﺒﻤﻜﺎﻥ ﺇﻨﺸﺎﺀ ﺘﻁﺒﻴﻘﺎﺕ ﺘﺭﺘﺒﻁ ﺒﻘﻭﺍﻋﺩ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻜﺘﺎﺒﺔ ﺍﻟﻜﻭﺩ ﺒﺸﻜل ﻤﺴﺎﻭ ﻟﺴﻬﻭﻟﺔ ﻜﺘﺎﺒﺘﻪ ﻓﻲ ﺘﻁﺒﻴﻘﺎﺕ ﻭﻨﺩﻭﺯ‪.‬‬
‫‪ ASP.NET Web‬ﺨﺩﻤﺎﺕ ‪ Web‬ﻤﻥ ﻨﻭﻉ ‪ .XML‬ﻭ ﻴﻬﺩﻑ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ‬
‫‪Service‬‬
‫ﺇﻟﻰ ﺃﺩﺍﺀ ﺨﺩﻤﺔ ﻴﻜﻭﻥ ﻨﺎﺘﺠﻬﺎ ﻤﻠﻑ ‪ .XML‬ﻤﺜل ﺨﺩﻤﺔ ﺘﺤﻭﻴل‬
‫ﺍﻟﻌﻤﻼﺕ ﻋﺒﺭ ﺍﻻﻨﺘﺭﻨﺕ‪ .‬ﻓﺄﻨﺕ ﺘﺴﺘﺩﻋﻲ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ‬
‫ﻟﻴﻌﻁﻴﻙ ﺍﻟﻨﺘﻴﺠﺔ ﻋﻠﻰ ﺸﻜل ﺍﻜﺱ ﺍﻡ ﺍل‪.‬‬
‫‪ Consol Application‬ﺘﻁﺒﻴﻕ ﻤﻤﺎﺜل ﻟﺘﻁﺒﻴﻘﺎﺕ ﺍﻟﺩﻭﺱ ‪.DOS‬‬
‫‪ Windows Service‬ﺘﻁﺒﻴﻘﺎﺕ ﺨﺩﻤﺎﺕ ﻭﻨﺩﻭﺯ ﻭ ﺘﻌﻤل ﻗﺒل ﺃﻥ ﻴﺴﺠل ﺍﻟﻤﺴﺘﺨﺩﻡ ﺍﻟﺩﺨﻭل ﺇﻟﻰ‬
‫ﻭﻨﺩﻭﺯ‪ .‬ﻭﺘﺴﺘﻁﻴﻊ ﺇﻨﺸﺎﺀ ﺨﺩﻤﺎﺕ ﻭﻨﺩﻭﺯ ﻷﺩﺍﺀ ﻫﺩﻑ ﻤﺎ ﺒﺴﻬﻭﻟﺔ ﻭﻫﻭ‬
‫ﻤﺎ ﻜﺎﻥ ﻤﺘﻌﺫﺭﺍ ﺇﻻ ﻋﻠﻰ ﻤﺤﺘﺭﻓﻲ ﺍﻟﺒﺭﻤﺠﺔ‪.‬‬
‫‪ Web Control Library‬ﺘﻁﺒﻴﻘﺎﺕ ﺘﻬﺩﻑ ﻹﻨﺸﺎﺀ ﺃﺩﻭﺍﺕ ﻴﻤﻜﻥ ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﻓﻲ ﺘﻁﺒﻴﻘﺎﺕ ﺍﻟﻭﺏ‬
‫ﻜﻤﺎ ﻫﻭ ﺍﻟﺤﺎل ﻓﻲ ﺃﺩﻭﺍﺕ ﻭﻨﺩﻭﺯ ‪.‬‬
‫ﺇﻨﺸﺎﺀ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‬
‫ﺃﻴﻥ ﺘﻨﺸﺄ ﺍﻟﻤﺸﺎﺭﻴﻊ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻭﻜﻴﻑ ﻴﺘﻡ ﺫﻟﻙ ؟‬

‫ﻤﻥ ﺍﻟﻔﺭﻭ ﻗﺎﺕ ﺍﻷﺴﺎﺴﻴﺔ ﺒﻴﻥ ﺒﻴﺌﺘﻲ ﻓﻴﺠﻭﺍل ﺒﻴﺴﻙ ‪ ٦‬ﻭ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﺃﻨﻪ ﺒﻤﺠﺭﺩ ﻀﻐﻁﻙ ﻋﻠﻰ ﺯﺭ‬
‫ﻤﻭﺍﻓﻕ ﻋﻨﺩ ﺇﻨﺸﺎﺀ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻓﺈﻥ ﻓﻴﺠﻭﺍل ﺴﺘﻭﺩﻴﻭ ﺩﻭﺕ ﻨﺕ ﻴﻘﻭﻡ ﺒﺈﻨﺸﺎﺀ ﻜل‬
‫ﺍﻟﻤﻠﻔﺎﺕ ﻭ ﺘﺨﺯﻴﻨﻬﺎ ﻓﻲ ﻤﺠﻠﺩ ﺒﺎﻻﺴﻡ ﺍﻟﺫﻱ ﺍﺨﺘﺭﺘﻪ ﻭﻓﻲ ﺍﻟﻤﻜﺎﻥ ﺍﻟﺫﻱ ﺍﺨﺘﺭﺘﻪ‪.‬‬
‫ﻋﻨﺩ ﺇﻨﺸﺎﺀ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ﻤﻥ ﻨﻭﻉ ﻭﻨﺩﻭﺯ ﻴﻘﻭﻡ ﻓﻴﺠﻭﺍل ﺴﺘﻭﺩﻴﻭ ﺒﺈﻨﺸﺎﺀ ﻤﺎ ﻴﺴﻤﻰ ﺒﺎﻟﺤل‪ ،‬ﻭﻫﻭ ﻋﺒﺎﺭﺓ‬
‫ﻋﻥ ﺘﻁﺒﻴﻕ ﻴﻤﻜﻥ ﺃﻥ ﻴﺤﻭﻱ ﺃﻜﺜﺭ ﻤﻥ ﻤﺸﺭﻭﻉ‪ .‬ﺩﺍﺨل ﻫﺫﺍ ﺍﻟﺤل ﻴﻘﻭﻡ ﻓﻴﺠﻭﺍل ﺴﺘﻭﺩﻴﻭ ﺒﺈﻨﺸﺎﺀ ﻤﺸﺭﻭﻉ‬
‫ﻭﺍﺤﺩ ﻜﻤﺎ ﻴﻘﻭﻡ ﺒﺈﻨﺸﺎﺀ ﻨﻤﻭﺫﺝ ﺩﺍﺨل ﻫﺫﺍ ﺍﻟﻤﺸﺭﻭﻉ‪.‬‬
‫ﻹﻨﺸﺎﺀ ﻤﺸﺭﻭﻉ ﻗﻡ ﺒﺎﻟﺨﻁﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ -١‬ﻗﻡ ﺒﻔﺘﺢ ﺒﺭﻨﺎﻤﺞ ﻓﻴﺠﻭﺍل ﺴﺘﻭﺩﻴﻭ ﺩﻭﺕ ﻨﺕ‪.‬‬
‫‪19‬‬
‫‪ -٢‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﺭﺌﻴﺴﻴﺔ ﺍﺨﺘﺭ ‪ File Î New ÎProject‬ﻜﻤﺎ ﻫﻭ ﻭﺍﻀﺢ ﻤﻥ ﺍﻟﺸﻜل )‪(٧-٢‬‬
‫ﺸﻜل ‪ : ٧ -٢‬ﻜﻴﻑ ﺘﻨﺸﺊ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ‬
‫‪ -٣‬ﺴﻭﻑ ﻴﻅﻬﺭ ﻟﻙ ﺍﻟﺸﻜل )‪ (٨-٢‬ﻭ ﺍﻟﺫﻱ ﻴﻨﻘﺴﻡ ﺇﻟﻰ ﺜﻼﺜﺔ ﺃﺠﺯﺍﺀ ‪:‬‬
‫• ﺍﻟﺠﺯﺀ ﺍﻷﻴﺴﺭ ﻭ ﺘﺴﺘﻁﻴﻊ ﻤﻥ ﺨﻼﻟﻪ ﺘﺤﺩﻴﺩ ﺍﻟﻠﻐﺔ ﺍﻟﺘﻲ ﺴﻭﻑ ﺘﻜﺘﺏ ﺍﻟﺘﻁﺒﻴﻕ ﻓﻴﻬﺎ‪.‬‬
‫• ﺍﻟﺠﺯﺀ ﺍﻷﻴﻤﻥ ﻭ ﺍﻟﺫﻱ ﻴﺤﻭﻱ ﻨﻭﻉ ﺍﻟﺘﻁﺒﻴﻕ ﺍﻟﺫﻱ ﺘﺭﻴﺩ ﺇﻨﺸﺎﺌﻪ‬
‫• ﺍﻟﺠﺯﺀ ﺍﻟﺴﻔﻠﻲ ﻭ ﺍﻟﺫﻱ ﺘﺴﺘﻁﻴﻊ ﻤﻥ ﺨﻼﻟﻪ ﺘﺤﺩﻴﺩ ﺍﺴﻡ ﺍﻟﻤﺸﺭﻭﻉ ﻭ ﺍﻟﻤﺴﺎﺭ ﺍﻟﺫﻱ‬
‫ﺴﻭﻑ ﻴﺨﺯﻥ ﻓﻴﻪ ﻭﻤﻥ ﺜﻡ ﺘﺤﺩﻴﺩ ﻤﺎ ﺇﺫﺍ ﺃﺭﺩﺕ ﺇﻀﺎﻓﺔ ﻫﺫﺍ ﺍﻟﻤﺸﺭﻭﻉ ﺇﻟﻰ ﺍﻟﻤﺸﺭﻭﻉ‬
‫ﺍﻟﻤﻔﺘﻭﺡ ﺇﻥ ﻭﺠﺩ ﺃﻭ ﺒﺩﺀ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ‪.‬‬
‫ﻗﻡ ﺒﺎﺨﺘﻴﺎﺭ ﻟﻐﺔ ﻓﻴﺠﻭﺍل ﺒﻴﺴﻙ ﺜﻡ ﻗﻡ ﺒﺎﺨﺘﻴﺎﺭ ‪ Windows Application‬ﺜﻡ ﺍﻜﺘﺏ ﺍﺴﻡ‬
‫ﺍﻟﻤﺸﺭﻭﻉ ‪ MyFirstApplication‬ﺜﻡ ﺍﻨﻘﺭ ﻋﻠﻰ ﺯﺭ ﻤﻭﺍﻓﻕ‬
‫ﺸﻜل ‪ : ٨ -٢‬ﺨﻴﺎﺭﺍﺕ ﺇﻨﺸﺎﺀ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ‬
‫‪20‬‬
‫ﻤﺎ ﺍﻟﺫﻱ ﺤﺩﺙ ؟‬

‫ﺒﻤﺠﺭﺩ ﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﻤﻭﺍﻓﻕ ﻗﺎﻡ ﻓﻴﺠﻭﺍل ﺴﺘﻭﺩﻴﻭ ﺒﺈﻨﺸﺎﺀ ﺤل ﻤﻜﻭﻥ ﻤﻥ ﻤﺸﺭﻭﻉ ﻭﺍﺤﺩ‬
‫ﺍﺴﻤﻪ ‪ MyFirstAppl‬ﻫﺫﺍ ﺍﻟﻤﺸﺭﻭﻉ ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﻨﻤﻭﺫﺝ ﻭﺍﺤﺩ ﺍﺴﻤﻪ ‪Form1.vb‬‬
‫ﻻﺤﻅ ﺃﻥ ﺍﻤﺘﺩﺍﺩ ﺍﻟﻨﻤﻭﺫﺝ ﻫﻭ ‪ vb‬ﻭﻫﺫﺍ ﺍﻻﻤﺘﺩﺍﺩ ﻴﺘﻡ ﺇﻨﺸﺎﺅﻩ ﺒﻨﺎﺀ ﻋﻠﻰ ﺍﻟﻠﻐﺔ ﺍﻟﺘﻲ‬
‫ﺍﺨﺘﺭﺕ ﺃﻥ ﺘﻜﺘﺏ ﺒﻬﺎ ﺍﻟﺘﻁﺒﻴﻕ‪ .‬ﻓﻠﻭ ﻗﻤﺕ ﺒﺎﺨﺘﻴﺎﺭ ﻟﻐﺔ ‪ C#‬ﻟﺘﻜﻭﻥ ﻟﻐﺔ ﻜﺘﺎﺒﺔ ﺍﻟﺘﻁﺒﻴﻕ ﻓﺈﻥ‬
‫ﺍﻤﺘﺩﺍﺩ ﺍﻟﻨﻤﺎﺫﺝ ﺴﻭﻑ ﻴﻜﻭﻥ ‪ CS‬ﻭﻫﻭ ﺍﺨﺘﺼﺎﺭ ‪.C Sharp‬‬
‫ﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﻤﻜﻭﻨﺎﺕ ﻓﻴﺠﻭﺍل ﺴﺘﻭﺩﻴﻭ ﺩﻭﺕ ﻨﺕ‬

‫ﻗﺒل ﺃﻥ ﻨﻜﻤل ﻜﺘﺎﺒﺔ ﺃﻭل ﺒﺭﻨﺎﻤﺞ ﻴﺤﺴﻥ ﺒﻨﺎ ﺃﻥ ﻨﺘﻌﺭﻑ ﻋﻠﻰ ﺒﻌﺽ ﺍﻟﻤﻜﻭﻨﺎﺕ ﻓﻲ ﺒﻴﺌﺔ‬
‫ﺍﻟﺩﻭﺕ ﻨﺕ ﻭ ﺍﻟﺘﻲ ﺴﻭﻑ ﺘﺴﺎﻋﺩﻨﺎ ﻓﻲ ﺇﻨﺸﺎﺀ ﺍﻟﻤﺸﺎﺭﻴﻊ ﻓﻲ ﺍﻟﻤﺴﺘﻘﺒل ﺇﻥ ﺸﺎﺀ ﺍﷲ‪.‬‬
‫ﻨﺎﻓﺫﺓ ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤﻠﻭل‬
‫ﺘﻭﺠﺩ ﻓﻲ ﺍﻟﺠﻬﺔ ﺍﻟﻴﻤﻨﻰ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ ﻭ ﺘﻌﺘﺒﺭ ﺍﻷﺩﺍﺓ ﺍﻷﺴﺎﺴﻴﺔ ﻟﻠﻌﻤل ﻤﻊ ﺍﻟﺤﻠﻭل ﻭ ﻤﻊ ﺍﻟﻤﺸﺎﺭﻴﻊ‬
‫– ﺍﻨﻅﺭ ﺸﻜل )‪ - (٩-٢‬ﻭﻫﻲ ﺃﺩﺍﺓ ﻤﻤﺎﺜﻠﺔ ﻟﻨﺎﻓﺫﺓ ﺍﻟﻤﺸﺭﻭﻉ ‪ Project Window‬ﺍﻟﺘﻲ ﻜﺎﻨﺕ ﻓﻲ‬
‫ﺍﻹﺼﺩﺍﺭ ﺍﻟﺴﺎﺩﺱ ﻏﻴﺭ ﺃﻨﻬﺎ ﺘﺤﻤل ﺇﻀﺎﻓﺎﺕ ﺃﺨﺭﻯ ﻤﺜل ﻋﺭﻀﻬﺎ ﻟﻠﻤﺭﺍﺠﻊ ﺍﻟﺘﻲ ﻴﺴﺘﺨﺩﻤﻬﺎ ﺍﻟﻤﺸﺭﻭﻉ‪.‬‬
‫ﻭﻴﻌﺭﺽ ﻤﺘﺼﻔﺢ ﺍﻟﻤﺸﺎﺭﻴﻊ ﻜل ﻋﻨﺎﺼﺭ ﺒﺭﻨﺎﻤﺠﻙ ﻤﻥ ﻤﺸﺎﺭﻴﻊ ﻭﻤﻜﻭﻨﺎﺕ‪ ،‬ﻭﻤﺎ ﻴﻨﺩﺭﺝ ﺘﺤﺕ ﻜل ﻤﻨﻬﺎ‬
‫ﻱ ﻤﻨﻬﺎ ﻤﺭﺘﻴﻥ ﺃﻥ ﺘﻌﺭﻀﻪ ﻓﻲ ﻤﺼﻤﻡ ﺍﻟﻨﻤﺎﺫﺝ ـ ﻟﻭ ﻜﺎﻥ‬
‫ﻤﻥ ﺃﻋﻀﺎﺀ ﻭﻋﻨﺎﺼﺭ‪ ،‬ﺒﺤﻴﺙ ﻴﻤﻜﻨﻙ ﺒﻨﻘﺭ ﺃ ‪‬‬
‫ﻤﻥ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺘﻲ ﺘﻌﺭﺽ ﻭﺍﺠﻬﺔ ـ ﺃﻭ ﻓﺘﺤﻪ ﻓﻲ ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ ﻟﻭ ﻜﺎﻥ ﻤﻠﻔﹰﺎ ﻨﺼﻴ‪‬ﺎ ﻓﺤﺴﺏ‪.‬‬
‫ﻜﻤﺎ ﻴﻤﻜﻨﻙ ﺃﻥ ﺘﹸﻅﻬﺭ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻤﻭﻀﻌﻴﺔ ﺒﻀﻐﻁ ﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻷﻴﻤﻥ ﻓﻭﻕ ﺃﻱ ﻋﻨﺼﺭ‪ ،‬ﺤﻴﺙ ﻴﻤﻜﻨﻙ‬
‫ﺍﺨﺘﻴﺎﺭ ﺍﻷﻤﺭ "ﺨﺼﺎﺌﺹ" ‪ ،Properties‬ﻟﺘﻌﺭﺽ ﻨﺎﻓﺫﺓ ﺍﻟﺨﺼﺎﺌﺹ‪ ،‬ﻟﺘﻌﺩ‪‬ل ﺨﺼﺎﺌﺹ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ ‪.‬‬
‫ﻭﺇﺫﺍ ﻜﺎﻥ ﺍﻟﻤﺸﺭﻭﻉ ﻴﺤﺘﻭﻱ ﻋﻠﻰ ﺃﻜﺜﺭ ﻤﻥ ﻨﻤﻭﺫﺝ‪ ،‬ﻭﺘﺭﻴﺩ ﺃﻥ ﺘﺠﻌل ﺃﺤﺩﻫﺎ ﻫﻭ ﺃﻭل ﻤﺎ ﻴﻅﻬﺭ ﻟﻙ ﻋﻨﺩ‬
‫ﺘﺸﻐﻴل ﺍﻟﺒﺭﻨﺎﻤﺞ‪ ،‬ﻓﺎﻀﻐﻁ ﺍﻷﻤﺭ "ﺍﺠﻌﻠﻪ ﻜﺎﺌﻥ ﺒﺩﺀ ﺍﻟﺘﺸﻐﻴل" ‪ Set As StartUp Object‬ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ‬
‫ﺍﻟﻤﻭﻀﻌﻴﺔ‪.‬‬
‫ﻤﻥ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺘﻲ ﻴﻤﻜﻥ ﺃﻥ ﺘﺠﺩﻫﺎ ﻓﻲ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻜل ﺍﻟﻨﻤﺎﺫﺝ ﺍﻟﺘﻲ ﺘﻭﺠﺩ ﻓﻲ ﺍﻟﻤﺸﺭﻭﻉ ﻓﻠﻭ‬
‫ﻨﻅﺭﺕ ﺇﻟﻰ ﺍﻟﺸﻜل)‪ (٩-٢‬ﻟﻭﺠﺩﺕ ﺃﻨﻪ ﻻ ﻴﻭﺠﺩ ﻟﺩﻴﻨﺎ ﺇﻻ ﻨﻤﻭﺫﺝ ﻭﺍﺤﺩ ﻭﻫﻭ ‪ Form1.vb‬ﺍﻟﺫﻱ‬
‫‪21‬‬
‫ﻗﺎﻤﺕ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﺒﺈﻨﺸﺎﺌﻪ ﻟﻨﺎ‪ .‬ﻋﻨﺩ ﺍﺨﺘﻴﺎﺭ ﺃﻱ ﻋﻨﺼﺭ ﻓﻲ ﺍﻟﻤﺴﺘﻜﺸﻑ ﺘﺴﺘﻁﻴﻊ ﺇﻅﻬﺎﺭ‬
‫ﺨﺼﺎﺌﺼﻪ‪.‬‬
‫ﻤﻥ ﺨﻼل ﺍﻴﻘﻭﻨﺎﺕ ﺼﻐﻴﺭﺓ ﺘﻅﻬﺭ ﻓﻲ ﻗﺎﺌﻤﺔ ﺍﻟﻤﺴﺘﻜﺸﻑ‪.‬‬
‫ﺸﻜل‪ : ٩ -٢‬ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤل‬
‫ﺇﺫﺍ ﺃﺭﺩﺕ ﺍﻻﻨﺘﻘﺎل ﺇﻟﻰ ﺃﻱ ﻋﻨﺼﺭ ﻓﻲ ﺍﻟﻤﺴﺘﻜﺸﻑ ﻴﻤﻜﻨﻙ ﺍﻟﻨﻘﺭ ﺍﻟﻤﺯﺩﻭﺝ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﻌﻨﺼﺭ‪.‬‬
‫ﻋﻠﻰ ﺴﺒﻴل ﺍﻟﻤﺜﺎل ﻟﻭ ﻜﺎﻥ ﻟﺩﻴﻙ ﺃﻜﺜﺭ ﻤﻥ ﻨﻤﻭﺫﺝ ﻓﻲ ﻨﻔﺱ ﺍﻟﻤﺸﺭﻭﻉ ﻓﺈﻨﻪ ﻴﻤﻜﻨﻙ ﺍﻻﻨﺘﻘﺎل ﻤﻥ‬
‫ﻨﻤﻭﺫﺝ ﺇﻟﻰ ﺁﺨﺭ ﺒﺎﻟﻨﻘﺭ ﺍﻟﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺫﻱ ﺘﺭﻏﺏ ﻓﻴﻪ ﻭﺴﻭﻑ ﻴﻅﻬﺭ ﺃﻤﺎﻤﻙ‪ .‬ﻋﻨﺩ‬
‫ﺍﺨﺘﻔﺎﺀ ﻨﺎﻓﺫﺓ ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤﻠﻭل ﻭﺘﺴﺘﻁﻴﻊ ﺇﻅﻬﺎﺭﻫﺎ ﻤﻥ ﺨﻼل ‪ Ctrl+Alt+L‬ﺃﻭ ﺍﻟﻘﺎﺌﻤﺔ‬
‫‪View ÎSolution Explorer‬‬
‫ﺇﻀﺎﻓﺔ ﻋﻨﺼﺭ ﺁﺨﺭ ﺇﻟﻰ ﺍﻟﻤﺸﺭﻭﻉ ﻓﺈﺫﺍ ﻜﻨﺕ ﺘﺭﻴﺩ ﺇﻀﺎﻓﺔ ﻨﻤﻭﺫﺝ ﺁﺨﺭ ﺇﻟﻰ ﺍﻟﻤﺸﺭﻭﻉ‬
‫ﺍﻟﺫﻱ ﺃﻨﺸﺄﺘﻪ‪ .‬ﻗﻡ ﺒﻤﺎ ﻴﻠﻲ ‪:‬‬
‫‪-١‬ﺍﻨﻘﺭ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻷﻴﻤﻥ ﻋﻠﻰ ﺍﺴﻡ ﺍﻟﻤﺸﺭﻭﻉ – ﻓﻲ ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤﻠﻭل‪ -‬ﻟﺘﻅﻬﺭ ﻟﻙ ﻗﺎﺌﻤﺔ‬
‫ﺍﺨﺘﺭ ‪ Add‬ﺴﻭﻑ ﺘﻅﻬﺭ ﻟﻙ ﻗﺎﺌﻤﺔ ﻓﺭﻋﻴﺔ ﺍﺨﺘﺭ ‪ Add New Item‬ﺍﻨﻅﺭ ﺸﻜل )‪(١٠-٢‬‬
‫‪22‬‬
‫‪ kal_judaia@ho‬ﻟﻠﻤﺸﺭﻭﻉ‬
‫‪ : ١٠ -tmail.com‬ﺇﻀﺎﻓﺔ ﻋﻨﺼﺭ‬
‫ﺸﻜل ‪٢‬‬ ‫ﺧﺎﻟﺪ اﻟﺠﺪﻳﻊ‬
‫‪ -٢‬ﺴﻭﻑ ﻴﻅﻬﺭ ﻟﻙ ﺍﻟﺸﻜل )‪ (١١-٢‬ﻭ ﺍﻟﺫﻱ ﻴﺤﻭﻱ ﻋﺩﺩ ﻤﻥ ﺃﻨﻭﺍﻉ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺘﻲ ﻴﻤﻜﻥ ﺃﻥ‬
‫ﺘﻀﻴﻔﻬﺎ ﺇﻟﻰ ﺍﻟﻤﺸﺭﻭﻉ‪ .‬ﻓﻌﻠﻰ ﺴﺒﻴل ﺍﻟﻤﺜﺎل ﺘﺴﺘﻁﻴﻊ ﺇﻀﺎﻓﺔ ﻨﻅﺎﻡ ﺘﻁﺒﻴﻘﻲ ﺇﻟﻰ ﺍﻟﻤﺸﺭﻭﻉ ﻭ‬
‫‪ HTML‬ﺇﺫﺍ ﺍﺤﺘﺠﺕ ﺇﻟﻰ ﺫﻟﻙ‪ .‬ﻤﺎ ﻨﺭﻴﺩ ﺃﻥ ﻨﻀﻴﻔﻪ ﺇﻟﻰ ﻤﺸﺭﻭﻋﻨﺎ ﻫﻭ ﻨﻤﻭﺫﺝ ﻤﻥ ﻨﻭﻉ‬
‫ﻭﻴﻨﺩﻭﺯ ﻭﻫﻭ ﻤﺎ ﻴﻭﺠﺩ ﺒﺎﺴﻡ ‪ Window Form‬ﻗﻡ ﺒﺎﻟﺘﻅﻠﻴل ﻋﻠﻴﻪ‪ .‬ﺴﻭﻑ ﺘﻼﺤﻅ ﻓﻲ ﺍﻷﺴﻔل‬
‫ﻤﺭﺒﻊ ﻨﺹ ﻻﺨﺘﻴﺎﺭ ﺍﺴﻡ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺫﻱ ﺘﺭﻴﺩ ﺇﻀﺎﻓﺘﻪ‪ .‬ﺘﺴﺘﻁﻴﻊ ﺘﻐﻴﻴﺭﻩ ﺃﻭ ﺘﺭﻜﻪ ﻜﻤﺎ ﻫﻭ‪.‬‬
‫ﺍﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ‪Open‬‬
‫ﺸﻜل ‪ : ١١-٢‬ﺃﻨﻭﺍﻉ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺘﻲ ﻴﻤﻜﻥ ﺇﻀﺎﻓﺘﻬﺎ ﻟﻠﻤﺸﺭﻭﻉ‬
‫‪23‬‬
‫ﺍﺭﺠﻊ ﺇﻟﻰ ﻨﺎﻓﺫﺓ ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤﻠﻭل ﻟﺘﻼﺤﻅ ﺃﻨﻪ ﻗﺩ ﺃﻀﻴﻑ ﻨﻤﻭﺫﺝ ﺁﺨﺭ ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ‬
‫ﺍﻟﺸﻜل )‪.(١٢-٢‬‬
‫ﻓﺈﺫﺍ ﺃﺭﺩﺕ ﺍﻟﺘﻨﻘل ﺒﻴﻥ ﺍﻟﻨﻤﻭﺫﺠﻴﻥ ﻴﻤﻜﻨﻙ ﺍﺨﺘﻴﺎﺭ ﺍﺤﺩ ﺍﻟﻁﺭﻴﻘﺘﻴﻥ ﺍﻟﺘﺎﻟﻴﺘﻴﻥ ‪:‬‬
‫ﺸﻜل ‪ : ١٢ -٢‬ﺍﻟﺘﻨﻘل ﺒﻴﻥ ﺍﻟﻨﻤﺎﺫﺝ‬
‫‪ .I‬ﺍﻟﻨﻘﺭ ﺍﻟﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺫﻱ ﺘﺭﻴﺩ ﺍﻻﻨﺘﻘﺎل ﺇﻟﻴﻪ ﻤﻥ ﺨﻼل ﻨﺎﻓﺫﺓ ﻤﺴﺘﻜﺸﻑ‬
‫ﺍﻟﺤﻠﻭل‪.‬‬
‫‪ .II‬ﺍﻟﻨﻘﺭ ﻤﺭﺓ ﻭﺍﺤﺩﺓ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺜﻡ ﺍﻟﻨﻘﺭ ﻋﻠﻰ ﻋﻨﺎﺼﺭ ﻗﺎﺌﻤﺔ ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤﻠﻭل ﻭﻫﻲ‬
‫‪ View Designer Form‬ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل)‪(١٣-٢‬‬
‫ﺸﻜل ‪ : ١٣ -٢‬ﻁﺭﻴﻘﺔ ﺃﺨﺭﻯ ﻟﻠﺘﻨﻘل‬
‫ﺒﻴﻥ ﺍﻟﻨﻤﺎﺫﺝ‬
‫ﺇﺫﺍ ﺃﺭﺩﺕ ﺃﻥ ﺘﺤﺫﻑ ﻋﻨﺼﺭًﺍ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪ ،Exclude From Project‬ﻓﺈﻥ ﻫﺫﺍ ﺍﻷﻤﺭ ﻻ‬
‫ﻴﻘﻭﻡ ﺒﺤﺫﻑ ﻤﻠﻑ ﺍﻟﻌﻨﺼﺭ ﻤﻥ ﺍﻟﺠﻬﺎﺯ ﻨﻬﺎﺌﻴﺎ ‪ ،‬ﺤﻴﺙ ﺘﺴﺘﻁﻴﻊ ﺇﻋﺎﺩﺘﻪ ﻟﻠﻤﺸﺭﻭﻉ ﻤﻥ ﺠﺩﻴﺩ‪ .‬ﺇﺫﺍ‬
‫ﺃﺭﺩﺕ ﺤﺫﻑ ﺍﻟﻤﻠﻑ ﻨﻬﺎﺌﻴًﺎ ﻤﻥ ﺍﻟﻤﺸﺭﻭﻉ ﻭﺍﻟﻘﺭﺹ ﺍﻟﺼﻠﺏ ﺍﺴﺘﺨﺩﻡ ﺍﻷﻤﺭ "ﺤﺫﻑ" ‪.Remove‬‬
‫‪24‬‬
‫ﺼﻨﺩﻭﻕ ﺍﻷﺩﻭﺍﺕ‬
‫ﻴﻭﺠﺩ ﻓﻲ ﺍﻟﺠﻬﺔ ﺍﻟﻴﺴﺭﻯ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ ﻭ ﻫﻭ ﺍﻟﻤﻜﺎﻥ ﺍﻟﺫﻱ ﻴﺤﻭﻱ ﺍﻷﺩﻭﺍﺕ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻓﻲ‬
‫ﺒﻨﺎﺀ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﻜﻤﺎ ﻴﻅﻬﺭ ﻟﻙ ﻤﻥ ﺍﻟﺸﻜل )‪. (١٤-٢‬‬
‫ﺸﻜل ‪:١٤ -٢‬ﺼﻨﺩﻭﻕ ﺍﻷﺩﻭﺍﺕ‬
‫ﻴﻭﺠﺩ ﺜﻼﺜﺔ ﻁﺭﻕ ﻹﻀﺎﻓﺔ ﺃﺩﺍﺓ ﺇﻟﻰ ﻨﻤﻭﺫﺝ ﻤﺎ ﻭﻫﻰ ﻜﻤﺎ ﻴﻠﻲ ‪:‬‬
‫‪ -١‬ﺍﻟﺴﺤﺏ ﻭ ﺍﻹﻓﻼﺕ ‪ :‬ﻭ ﺫﻟﻙ ﺒﺴﺤﺏ ﺍﻷﺩﺍﺓ ﺍﻟﻤﺭﺍﺩ ﻭ ﻀﻌﻬﺎ ﻓﻲ ﺍﻟﻨﻤﻭﺫﺝ ﻭﻤﻥ ﺜﻡ ﺇﻓﻼﺘﻬﺎ ﻓﻲ‬
‫ﻤﺤﻴﻁ ﺍﻟﻨﻤﻭﺫﺝ‪.‬‬
‫‪ -٢‬ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﻨﻘﺭ ﺍﻟﻤﺯﺩﻭﺝ ‪ :‬ﻭﺫﻟﻙ ﺒﺎﻟﻨﻘﺭ ﺍﻟﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺍﻷﺩﺍﺓ – ﺍﻨﺘﺒﻪ ﻟﻠﻤﻼﺤﻅﺔ ﺍﻟﺘﺎﻟﻴﺔ –‬
‫ﻭﻫﻭ ﻤﺎ ﺴﻴﻀﻴﻔﻬﺎ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ‪.‬‬
‫‪ -٣‬ﺍﻟﻨﺴﺦ ‪ :‬ﻭﺫﻟﻙ ﺒﻨﺴﺦ ﺃﺩﺍﺓ ﻤﻭﺠﻭﺩﺓ ﻤﺴﺒﻘﺎ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻭﻤﻥ ﺜﻡ ﻟﺼﻘﻬﺎ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻹﻀﺎﻓﺔ ﺃﺩﺍﺓ ﺇﻟﻰ ﻨﻤﻭﺫﺝ ﻻﺒﺩ ﺃﻥ ﻴﻜﻭﻥ ﺍﻟﻨﻤﻭﺫﺝ ﻤﻔﺘﻭﺤﺎ ﺒﺸﻜﻠﻪ ﺍﻟﺘﺼﻤﻴﻤﻲ ﻭ ﻟﻴﺱ ﺒﺸﻜل‬
‫ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ‪.‬‬
‫ﻤﻥ ﺍﻹﻀﺎﻓﺎﺕ ﺍﻟﺠﺩﻴﺩﺓ ﺇﻟﻰ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻓﻴﻤﺎ ﻴﺨﺘﺹ ﺒﺼﻨﺩﻭﻕ ﺍﻷﺩﻭﺍﺕ ﻫﻲ ﺃﻨﻙ‬
‫ﺘﺴﺘﻁﻴﻊ ﺇﻀﺎﻓﺔ ﻤﺩﺨل ﺠﺩﻴﺩ ﺇﻟﻰ ﺼﻨﺩﻭﻕ ﺍﻷﺩﻭﺍﺕ ﺃﻭ ﺤﺫﻑ ﺃﻭ ﺘﻌﺩﻴل ﻭ ﻫﻲ ﺇﻀﺎﻓﺔ ﻗﻭﻴﺔ ﻟﻠﺘﺤﻜﻡ‬
‫ﺒﺘﻨﻅﻴﻡ ﺍﻷﺩﻭﺍﺕ ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪. (١٦-٢‬‬
‫‪25‬‬
‫ﻭﻹﻀﺎﻓﺔ ﺸﺭﻴﻁ ﺠﺩﻴﺩ –‪ -Tab‬ﻗﻡ ﺒﺎﻟﺘﺎﻟﻲ ‪:‬‬

‫‪ -١‬ﺍﻟﻨﻘﺭ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻷﻴﻤﻥ ﻋﻠﻰ ﺼﻨﺩﻭﻕ ﺍﻷﺩﻭﺍﺕ ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل )‪ (١٥-٢‬ﻟﺘﻅﻬﺭ ﻟﻙ‬
‫ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﺘﻲ ﺘﺭﺍﻫﺎ ﺜﻡ ﺍﺨﺘﺭ ‪Add Tab‬‬
‫ﺸﻜل ‪ : ١٥-٢‬ﺇﻀﺎﻓﺔ ﺸﺭﻴﻁ ﺠﺩﻴﺩ ﺇﻟﻰ ﺼﻨﺩﻭﻕ ﺍﻷﺩﻭﺍﺕ‬
‫‪ -٢‬ﺴﻭﻑ ﻴﻔﺘﺢ ﻟﻙ ﻤﻜﺎﻨﺎ ﻟﻜﺘﺎﺒﺔ ﺍﺴﻡ ﺍﻟﺸﺭﻴﻁ ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل )‪ ) (١٦-٢‬ﻻﺤﻅ ﺃﻨﻨﻲ‬
‫ﻜﺘﺒﺕ ‪( This Is New Tab‬‬
‫ﺸﻜل ‪ : ١٦ -٢‬ﺘﺴﻤﻴﺔ ﺍﻟﺸﺭﻴﻁ‬
‫ﺍﻟﺠﺩﻴﺩ‬
‫‪26‬‬
‫ﻭﻴﺤﺘﻭﻱ ﺼﻨﺩﻭﻕ ﺍﻷﺩﻭﺍﺕ ﻋﻠﻰ ﺍﻷﺸﺭﻁﺔ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬
‫ﺘﻘﺎﺭﻴﺭ ﻜﺭﻴﺴﺘﺎل ‪:Crystal Reports‬‬

‫ﻭﺒﻬﺎ ﺍﻷﺩﻭﺍﺕ ﺍﻟﻼﺯﻤﺔ ﻹﻨﺸﺎﺀ ﻭ ﺘﺼﻤﻴﻡ ﺍﻟﺘﻘﺎﺭﻴﺭ ﺍﻟﻤﺨﺘﻠﻔﺔ‪ .‬ﺍﻟﻨﺴﺨﺔ ﺍﻟﺘﻲ ﺘﺄﺘﻲ ﻤﻊ ﺍﻟﺩﻭﺕ ﻨﺕ ﻨﺴﺨﺔ‬
‫ﻤﺤﺩﻭﺩﺓ ﺍﻻﻤﻜﺎﻨﺎﺕ‪.‬‬
‫"ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ" ‪:Data‬‬
‫ﻭﺘﺤﺘﻭﻱ ﻋﻠﻰ ﺍﻷﺩﻭﺍﺕ ﺍﻟﺘﻲ ﺘﺴﺘﺨﺩ ُﻡ ﻟﻼﺘﺼﺎل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻗﺭﺍﺀﺓ ﻭﺘﺤﺩﻴﺙ ﺒﻴﺎﻨﺎﺘﻬﺎ‪.‬‬
‫"ﻨﻤﺎﺫﺝ ﺍﻟﻭﻴﻨﺩﻭﺯ" ‪:Windows Forms‬‬

‫ﻭﺘﺤﺘﻭﻱ ﻋﻠﻰ ﺍﻷﺩﻭﺍﺕ ﺍﻟﺘﻲ ﺘﺴﺘﺨﺩﻡ ﻤﻊ ﻨﻤﺎﺫﺝ ﺍﻟﻭﻴﻨﺩﻭﺯ‪.‬‬
‫"ﻨﻤﺎﺫﺝ ﺍﻹﻨﺘﺭﻨﺕ" ‪:Web Forms‬‬

‫ﻭﺘﺤﺘﻭﻱ ﻋﻠﻰ ﺍﻷﺩﻭﺍﺕ ﺍﻟﺘﻲ ﺘﺴﺘﺨﺩﻡ ﻤﻊ ﻨﻤﺎﺫﺝ ﺍﻹﻨﺘﺭﻨﺕ ﻭﻫﺫﻩ ﺍﻷﺩﻭﺍﺕ ‪ Web Control‬ﺘﻌﻁﻲ‬
‫ﺴﻬﻭﻟﺔ ﻓﻲ ﺘﺼﻤﻴﻡ ﺘﻁﺒﻴﻘﺎﺕ ﺍﻻﻨﺘﺭﻨﺕ‪.‬‬
‫"ﺃﺩﻭﺍﺕ ‪:HTML‬‬
‫ﻭﺘﺤﺘﻭﻱ ﻋﻠﻰ ﺍﻷﺩﻭﺍﺕ ﺍﻟﺘﻲ ﺘﺴﺘﺨﺩﻡ ﻤﻊ ﻨﻤﺎﺫﺝ ﺍﻹﻨﺘﺭﻨﺕ‪.‬‬
‫‪27‬‬
‫ﻜﺘﺎﺒﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ‬
‫ﺘﺴﺘﻁﻴﻊ ﻜﺘﺎﺒﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻤﻥ ﺨﻼل ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ )ﺍﻟﺸﻔﺭﺍﺕ(‪.‬‬

‫ﺃ ـ ﻜﻴﻔﻴﺔ ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ ‪:‬‬
‫ﻟﻠﻭﺼﻭل ﺇﻟﻰ ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ ﻗﻡ ﺒﺈﻀﺎﻓﺔ ﺯﺭ ﺃﻤﺭ ﻤﻥ ﺼﻨﺩﻭﻕ ﺍﻷﺩﻭﺍﺕ ﺜﻡ ﻨﻔﺫ ﺃﻱ ﻤﻥ ﺍﻟﻁﺭﻕ‬
‫ﺍﻟﺜﻼﺙ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻟﻠﺘﻌﺭﻑ ﺃﻜﺜﺭ ﻋﻠﻰ ﻫﺫﻩ ﺍﻷﺩﺍﺓ ﺍﻗﺭﺃ ﺍﻟﺠﺯﺀ ﺍﻟﺨﺎﺹ ﺒﺨﺼﺎﺌﺹ ﺯﺭ ﺍﻷﻤﺭ ﻓﻲ ﺍﻟﻔﺼل‬
‫ﺍﻟﺘﺎﻟﻲ‬
‫ﻟﻠﻭﺼﻭل ﺇﻟﻰ ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ ﻴﻭﺠﺩ ﺜﻼﺜﺔ ﻁﺭﻕ ‪:‬‬
‫‪ -١‬ﺍﻟﻨﻘﺭ ﺍﻟﻤﺯﺩﻭﺝ ‪ :‬ﻋﻨﺩ ﺍﻟﻨﻘﺭ ﺍﻟﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺃﻱ ﺃﺩﺍﺓ ﻓﺈﻥ ﺫﻟﻙ ﺴﻭﻑ ﻴﻘﻭﻡ ﺒﻨﻘﻠﻙ ﺇﻟﻰ ﻤﺤﺭﺭ‬
‫ﺍﻟﻜﻭﺩ‪.‬‬
‫‪ -٢‬ﻤﻥ ﺨﻼل ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤﻠﻭل ‪ :‬ﺍﻷﻴﻘﻭﻨﺔ ﺍﻷﻭﻟﻰ ﻤﻥ ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤﻠﻭل ﺘﻨﻘﻠﻙ ﺇﻟﻰ ﻤﺤﺭﺭ‬
‫ﺍﻟﻜﻭﺩ ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل )‪ (١٧-٢‬ﻭ ﺍﻷﻴﻘﻭﻨﺔ ﺍﻟﺘﻲ ﺒﺠﺎﻨﺒﻬﺎ ﺘﻨﻘﻠﻙ ﺇﻟﻰ ﻭﻀﻊ ﺘﺼﻤﻴﻡ‬
‫ﺍﻟﻨﻤﻭﺫﺝ‪.‬‬
‫ﺸﻜل ‪ : ١٧ -٢‬ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ ﻤﻥ ﺨﻼل‬

‫ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤل‬
‫‪28‬‬
‫‪ -٣‬ﺍﻟﻨﻘﺭ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻷﻴﻤﻥ ﻋﻠﻰ ﺃﻱ ﺃﺩﺍﺓ ﻤﻭﺠﻭﺩﺓ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺜﻡ ﺍﺨﺘﻴﺎﺭ ‪ ViewCode‬ﻜﻤﺎ‬
‫ﻴﻅﻬﺭ ﻤﻥ ﺸﻜل )‪(١٨-٢‬‬
‫ﺸﻜل ‪ : ١٨ -٢‬ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ ﻤﻥ ﺍﻟﻨﻤﻭﺫﺝ‬
‫ﺒﻌﺩ ﺍﻻﻨﺘﻘﺎل ﺇﻟﻰ ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ ﺃﻨﻅﺭ ﺍﻟﺸﻜل )‪ (١٩-٢‬ﻭﻫﻭ ﻤﺎ ﻴﻤﺜل ﻭﺍﺠﻬﺔ ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ‪.‬‬
‫ﺸﻜل ‪١٩-٢‬‬
‫ﻟﻠﺭﺠﻭﻉ ﺇﻟﻰ‬
‫ﻭﺍﺠﻬﺔ ﺘﺼﻤﻴﻡ‬
‫ﺍﻟﻨﻤﻭﺫﺝ‬
‫ﺍﻟﻜﻭﺩ ﺍﻟﻤﻨﺘﺞ ﻤﻥ‬

‫ﻗﺒل ﻓﻴﺠﻭﺍل‬
‫ﺴﺘﻭﺩﻴﻭ‬
‫‪29‬‬
‫ﺏ ـ ﻤﻤﻴﺯﺍﺕ ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ‪:‬‬

‫ﺘﻭﺠﺩ ﻋﺩﺓ ﻤﻤﻴﺯﺍﺕ ﻟﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻴﺠﺩﺭ ﺒﻙ ﻤﻌﺭﻓﺘﻬﺎ ﻷﻨﻬﺎ ﺘﺴﻬل‬
‫ﺍﻟﻌﻤل ﺃﺜﻨﺎﺀ ﻋﻤﻠﻴﺔ ﺍﻟﺒﺭﻤﺠﺔ‪ ،‬ﺴﻭﻑ ﻨﺘﻌﺭﺽ ﻟﺨﻤﺱ ﻤﻴﺯﺍﺕ ﻤﻨﻬﺎ ‪:‬‬
‫‪ .I‬ﻨﻤﻁ ﺍﻻﺨﺘﻴﺎﺭ ﺍﻟﻤﺭﺒﻊ ‪ :‬ﻭﻴﻤﻜﻨﻙ ﻤﻥ ﺍﻟﺘﻅﻠﻴل ﺍﻟﺩﻗﻴﻕ ﻟﻤﺎ ﺘﺭﻴﺩ ﻤﻥ ﻜﻭﺩ‪ ،‬ﻭ ﻴﺤﺼل ﻋﻨﺩ‬
‫ﻀﻐﻁ ﺯﺭ ‪ alt‬ﻭ ﺘﺤﺭﻴﻙ ﺍﻟﻔﺄﺭﺓ ﻷﺴﻔل ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪(٢٠-٢‬‬
‫‪ .II‬ﺍﻟﺘﺤﺭﻴﺭ ﺍﻟﺫﻜﻲ ‪ :‬ﺤﻴﺙ ﺘﻘﻭﻡ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﺒﺘﺭﺘﻴﺏ ﺍﻟﻜﻭﺩ ﺍﻟﺫﻱ ﺘﻜﺘﺒﻪ ﺘﺭﺘﻴﺒﺎ ﻴﺴﻬل‬
‫ﻋﺭﻀﻪ ﻭ ﻗﺭﺍﺀﺘﻪ ﻤﺜل ﺘﺭﺘﻴﺏ ﺠﻤل ﺍﻟﺸﺭﻁ ﻭ ﺠﻤل ﺍﻟﺘﻜﺭﺍﺭ‪ .‬ﻟﻥ ﺘﺤﺘﺎﺝ ﺒﻌﺩ ﺍﻟﻴﻭﻡ ﺇﻟﻰ‬
‫ﺍﻟﺒﺤﺙ ﻋﻥ ﺠﻤﻠﺔ ‪ If‬ﻭﺠﻤﻠﺔ ‪ Else if‬ﻟﻭﻀﻌﻬﻤﺎ ﺒﻭﻀﻊ ﻤﺘﻭﺍﺯﻱ ﻓﺴﻭﻑ ﺘﻘﻭﻡ ﺒﻴﺌﺔ‬
‫ﺍﻟﺩﻭﺕ ﻨﺕ ﺒﻌﻤل ﺫﻟﻙ ﻨﻴﺎﺒﺔ ﻋﻨﻙ‪.‬‬
‫‪ .III‬ﺇﻜﻤﺎل ﺍﻟﺠﻤل ‪ :‬ﻤﺜل ﺇﻜﻤﺎل ﺘﺭﻜﻴﺏ ﺍﻟﺠﻤل ﺍﻟﻤﺸﻬﻭﺭﺓ ﻤﺜل ‪select case,if,do‬‬
‫ﻭﻏﻴﺭﻫﺎ‪.‬ﻭ ﻟﻥ ﺘﺤﺘﺎﺝ ﺒﻌﺩ ﺍﻟﻴﻭﻡ ﺇﻟﻰ ﺤﻔﻅ ﺼﻴﻐﺔ ﺠﻤﻠﺔ ‪ If‬ﺃﻭ ﺠﻤﻠﺔ ‪Select Case‬‬
‫ﻓﺒﻤﺠﺭﺩ ﻤﺎ ﺘﻜﺘﺏ ﺠﻤﻠﺔ ‪ If‬ﺜﻡ ﺍﻟﺸﺭﻁ ﺜﻡ ﺘﻘﻭﻡ ﺒﻀﻐﻁ ﺯﺭ ‪ Enter‬ﺴﻭﻑ ﺘﻘﻭﻡ ﺍﻟﺩﻭﺕ‬
‫ﻨﺕ ﺒﺈﻜﻤﺎل ﺍﻟﺠﻤﻠﺔ ﻨﻴﺎﺒﺔ ﻋﻨﻙ‪.‬‬
‫‪ .IV‬ﺘﺠﺯﺉ ﺍﻟﺠﻤل ‪ :‬ﻤﻥ ﺨﻼل ‪Edit Î Advance Î Word Wrapping‬‬
‫ﻋﻨﺩ ﺇﻋﻤﺎل ﻫﺫﻩ ﺍﻟﻤﻤﻴﺯﺓ ﺴﻭﻑ ﺘﻘﻭﻡ ﺍﻟﺩﻭﺕ ﻨﺕ ﺒﺘﻘﺴﻴﻡ ﺍﻷﺴﻁﺭ ﺍﻟﻁﻭﻴﻠﺔ ﺇﻟﻰ ﺴﻁﺭﻴﻥ ﺃﻭ‬
‫ﺃﻜﺜﺭ ﻟﺘﺴﻬل ﻋﻤﻠﻴﺔ ﻗﺭﺍﺀﺓ ﺍﻟﻜﻭﺩ‪.‬‬
‫‪ .V‬ﺘﺭﻗﻴﻡ ﺍﻷﺴﻁﺭ ‪ :‬ﺘﺘﻴﺢ ﻟﻙ ﻫﺫﻩ ﺍﻟﻤﻴﺯﺓ ﺍﻟﺘﺭﻗﻴﻡ ﺍﻵﻟﻲ ﻷﺴﻁﺭ ﺍﻟﻜﻭﺩ‪.‬‬
‫‪Tool – Option – Text Editor - General – All Language – Line Numbers‬‬
‫ﺸﻜل ‪ : ٢٠-٢‬ﻁﺭﻴﻘﺔ ﺩﻗﻴﻘﺔ ﻟﺘﻅﻠﻴل ﺍﻟﻜﻭﺩ‬
‫‪30‬‬
‫ﺍﻟﺨﺼﺎﺌﺹ ‪Properties‬‬
‫ﺘﺘﻤﻴﺯ ﻜل ﺃﺩﺍﺓ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﺒﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﺨﺼﺎﺌﺹ‪ .‬ﻴﻤﻜﻥ ﺃﻥ ﺘﻌﺭﻑ ﺍﻟﺨﺼﺎﺌﺹ ﻋﻠﻰ‬
‫ﺃﻨﻬﺎ ﻤﺎ ﻴﺘﻤﻴﺯ ﺒﻪ ﺍﻟﻜﺎﺌﻥ ﻤﻥ ﻤﻭﺍﺼﻔﺎﺕ ﻤﺜل ﺍﻟﻁﻭل‪ ،‬ﺍﻟﻌﺭﺽ‪ ،‬ﺍﻟﻠﻭﻥ ‪...‬ﺍﻟﺦ‪ .‬ﻭﻫﺫﻩ ﺍﻟﺨﺼﺎﺌﺹ‬
‫ﻗﺩ ﻴﺘﺸﺎﺒﻪ ﺒﻌﻀﻬﺎ ﺒﻴﻥ ﺃﺩﺍﺘﻴﻥ ﻤﺨﺘﻠﻔﺘﻴﻥ ﻭﻫﻭ ﻤﺎ ﻴﺘﻜﺭﺭ ﻜﺜﻴﺭﺍ ﻭ ﻗﺩ ﺘﺘﻤﻴﺯ ﻜل ﺃﺩﺍﺓ ﺒﺨﺎﺼﻴﺔ ﺃﻭ‬
‫ﺃﻜﺜﺭ ﻻ ﺘﻭﺠﺩ ﺇﻻ ﻓﻴﻬﺎ‪ .‬ﻴﻭﺠﺩ ﻁﺭﻴﻘﺘﻴﻥ ﻟﺘﻌﻴﻴﻥ ﺨﺎﺼﻴﺔ ﻷﺩﺍﺓ ﻤﺎ ﻫﻤﺎ ‪:‬‬
‫‪ -١‬ﺇﻋﻁﺎﺀ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺃﺜﻨﺎﺀ ﻭﻗﺕ ﺍﻟﺘﺼﻤﻴﻡ‪.‬‬
‫‪ -٢‬ﺇﻋﻁﺎﺀ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺃﺜﻨﺎﺀ ﻭﻗﺕ ﺍﻟﺘﺸﻐﻴل‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻴﻭﺠﺩ ﻓﺼل ﻜﺎﻤل ﻴﺘﻜﻠﻡ ﻋﻥ ﺨﺼﺎﺌﺹ ﺍﻷﺩﻭﺍﺕ ﻭ ﺍﻟﻘﻴﻡ ﺍﻟﺘﻲ ﺘﺄﺨﺫﻫﺎ ﻭ ﺸﺭﺡ ﻜل ﻗﻴﻤﺔ ﻭ‬
‫ﻤﺜﺎل ﺘﻁﺒﻴﻘﻲ ﻋﻠﻴﻬﺎ‪ .‬ﻴﺠﺩﺭ ﺒﻙ ﻤﺭﺍﺠﻌﺔ ﻫﺫﺍ ﺍﻟﻔﺼل ﻭ ﺍﻟﺘﻤﺭﻥ ﻋﻠﻴﻪ ﺠﻴﺩﺍ‬
‫ﺃ ـ ﻜﻴﻑ ﺘﻌﻴﻥ ﺨﺼﺎﺌﺹ ﺃﺩﺍﺓ‬

‫ﺘﻭﺠﺩ ﻨﺎﻓﺫﺓ ﺘﺴﻤﻰ ﻨﺎﻓﺫﺓ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻨﻅﺭ ﺸﻜل )‪ -Propherty Window– (٢٢-٢‬ﻭﺘﻭﺠﺩ‬
‫ﻋﺎﺩﺓ ﻓﻲ ﺍﻟﺠﻬﺔ ﺍﻟﻴﻤﻨﻰ ﻟﺒﻴﺌﺔ ﺍﻟﺘﻁﻭﻴﺭ‪ ،‬ﻭﻫﺩﻑ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ﻫﻲ ﺘﻌﻴﻴﻥ ﺨﺼﺎﺌﺹ ﺍﻷﺩﻭﺍﺕ‪ .‬ﻴﻭﺠﺩ‬
‫ﻋﺩﺓ ﻁﺭﻕ ﻟﻠﻭﺼﻭل ﺇﻟﻰ ﻫﺫﻩ ﺍﻟﻨﺎﻓﺫﺓ ‪:‬‬
‫‪ -١‬ﺍﻟﻨﻘﺭ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻷﻴﻤﻥ ﻋﻠﻰ ﺃﻱ ﺃﺩﺍﺓ ﻤﻭﺠﻭﺩﺓ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺜﻡ ﺍﺨﺘﻴﺎﺭ ‪ Properties‬ﻜﻤﺎ‬
‫ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل )‪(٢١-٢‬‬
‫ﺸﻜل ‪ : ٢١ -٢‬ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﺨﺼﺎﺌﺹ ﺃﺩﺍﺓ ﻤﺎ‬
‫‪31‬‬
‫‪ -٢‬ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﺜﺎﻨﻴﺔ ﻟﻠﻭﺼﻭل ﺇﻟﻰ ﻨﺎﻓﺫﺓ ﺍﻟﺨﺼﺎﺌﺹ ﺃﻥ ﺘﻘﻭﻡ ﺒﺎﺨﺘﻴﺎﺭ ﺍﻟﺘﺎﻟﻲ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﺭﺌﻴﺴﻴﺔ‬
‫‪View Î Property Window‬‬
‫ﺷﻜﻞ ‪ : ٢٢-٢‬ﺃﻗﺴﺎﻡ ﻧﺎﻓﺬﺓ ﺍﳋﺼﺎﺋﺺ‬

‫ﻗﺎﺋﻤﺔ اﻷدوات‬
‫اﻷدوات‬ ‫ﻗﺎﺋﻤﺔ‬
‫ﻋﺮض اﻟﺨﺼﺎﺋﺺ‬
‫اﻟﺨﺼﺎﺋﺺ‬ ‫ﺧﻴﺎرات ﻋﺮض‬
‫ﺧﻴﺎرات‬
‫ﺧﺼﺎﺋﺺ ﻓﺮﻋﻴﺔ‬
‫ﻓﺮﻋﻴﺔ‬ ‫وﺟﻮد ﺧﺼﺎﺋﺺ‬
‫ﻻﺣﻆ وﺟﻮد‬
‫ﻻﺣﻆ‬
‫ﻟﺨﺎﺻﻴﺔ اﻟﺨﻂ‬
‫اﻟﺨﻂ‬ ‫ﻟﺨﺎﺻﻴﺔ‬
‫‪ -٣‬ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ‪.F4‬‬
‫ﺏ ـ ﻁﺭﻕ ﻋﺭﺽ ﺘﺭﺘﻴﺏ ﺍﻟﺨﺼﺎﺌﺹ ‪:‬‬

‫ﻴﻭﺠﺩ ﻫﻨﺎﻙ ﻁﺭﻴﻘﺘﻴﻥ ﺃﺴﺎﺴﻴﺘﻴﻥ ﻟﻌﺭﺽ ﺘﺭﺘﻴﺏ ﺍﻟﺨﺼﺎﺌﺹ ﻓﻲ ﻨﺎﻓﺫﺓ ﺍﻟﺨﺼﺎﺌﺹ ‪:‬‬
‫‪ .i‬ﺍﻟﺘﺭﺘﻴﺏ ﺍﻷﻟﻑ ﺒﺎﺌﻲ ‪ :‬ﻭﻫﻭ ﺘﺭﺘﻴﺏ ﺍﻟﺨﺼﺎﺌﺹ ﺤﺴﺏ ﺍﻟﺤﺭﻭﻑ ﺍﻷﺒﺠﺩﻴﺔ‬
‫ﻓﻌﻠﻰ ﺴﺒﻴل ﺍﻟﻤﺜﺎل ﺴﻭﻑ ﻨﺠﺩ ﺃﻥ ﺨﺎﺼﻴﺔ ‪ Font‬ﺘﺄﺘﻲ ﻗﺒل ﺨﺎﺼﻴﺔ ‪Text‬‬
‫ﻷﻥ ﺤﺭﻑ ‪ F‬ﻴﺴﺒﻕ ﺤﺭﻑ ‪.T‬‬
‫ﺍﻟﺨﺼﺎﺌﺹ ﺇﻟﻰ‬ ‫‪ .ii‬ﺍﻟﺘﺭﺘﻴﺏ ﺍﻟﺘﺼﻨﻴﻔﻲ ‪ :‬ﻭﻓﻲ ﻫﺫﺍ ﺍﻟﺘﺭﺘﻴﺏ ﻴﺘﻡ ﺘﺼﻨﻴﻑ‬
‫ﻤﺠﻤﻭﻋﺎﺕ ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪ (٢٣-٢‬ﻭﻤﻥ ﺜﻡ ﺇﺩﺭﺍﺠﻬﺎ ﺘﺤﺕ ﺘﻠﻙ‬
‫ﺍﻟﻤﺠﻤﻭﻋﺎﺕ ﻓﻌﻠﻰ ﺴﺒﻴل ﺍﻟﻤﺜﺎل ﻤﺠﻤﻭﻋﺔ ‪ Appearance‬ﺘﺤﻭﻱ ﺨﺎﺼﻴﺔ‬
‫‪ Backcolor‬ﻭ ﺨﺎﺼﻴﺔ ‪.Font‬‬
‫‪32‬‬
‫ﺸﻜل ‪ : ٢٣ -٢‬ﺍﻟﻌﺭﺽ ﺍﻟﺘﺼﻨﻴﻔﻲ‬

‫ﻟﻠﺨﺼﺎﺌﺹ‬
‫ﺝ ـ ﺘﻁﺒﻴﻕ ‪:‬‬
‫‪ -١‬ﻗﻡ ﺒﺈﻀﺎﻓﺔ ﺯﺭ ﺃﻤﺭ‬
‫‪ -٢‬ﺍﻨﻘﺭ ﺒﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻷﻴﻤﻥ ﻋﻠﻴﻪ ﺜﻡ ﺍﺨﺘﺭ ‪Properties‬‬
‫‪ -٣‬ﺍﺫﻫﺏ ﺇﻟﻰ ﺨﺎﺼﻴﺔ ‪ Text‬ﻭ ﺍﻜﺘﺏ ﻤﺤﺎﻭﻟﺔ ﺘﻐﻴﻴﺭ‬
‫ﺍﻟﺨﺼﺎﺌﺹ‪.‬‬
‫‪ -٤‬ﻻﺤﻅ ﻜﻴﻑ ﺘﻐﻴﺭ ﺍﻟﻨﺹ ﺍﻟﻤﻜﺘﻭﺏ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ‬
‫‪33‬‬
‫ﺍﻷﺤﺩﺍﺙ ‪Events‬‬
‫ﻴﻤﻜﻥ ﺘﻌﺭﻴﻔﻪ ﺒﺯﻤﻥ ﺤﺼﻭﻟﻪ ﺤﻴﺙ ﻴﺤﺼل ﻋﻨﺩ ﻗﻴﺎﻡ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺃﻭ ﺍﻟﻨﻅﺎﻡ ﺒﻌﻤل ﻤﺎ ﺘﺠﺎﻩ ﺃﺩﺍﺓ ﻤﺎ‪ ،‬ﻤﺜل‬
‫ﻨﻘﺭ ﺒﺎﻟﻔﺄﺭﺓ ﻋﻠﻰ ﺯﺭ ﺃﻤﺭ‪ ،‬ﻟﺘﻐﻴﻴﺭ ﻤﺤﺘﻭﻱ ﺼﻨﺩﻭﻕ ﺍﻟﻨﺹ‪ .‬ﻓﻠﻭ ﺃﺨﺫﻨﺎ ﻋﻠﻰ ﺴﺒﻴل ﺍﻟﻤﺜﺎل ﺃﺩﺍﺓ ﺯﺭ‬
‫ﺍﻷﻤﺭ ﻟﻭﺠﺩﻨﺎ ﺃﻨﻪ ﺒﻤﺠﺭﺩ ﻨﻘﺭ ﺍﻟﻔﺄﺭﺓ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ ﻓﺈﻥ ﺤﺩﺙ ﺍﻟﻨﻘﺭ ﺴﻭﻑ ﻴﻌﻤل‪ .‬ﻓﺈﺫﺍ ﺃﺭﺩﺕ ﺃﻥ‬
‫ﺘﻅﻬﺭ ﺭﺴﺎﻟﺔ ﻋﻨﺩ ﺍﻟﻨﻘﺭ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ ﻓﺈﻨﻙ ﺴﻭﻑ ﺘﻜﺘﺏ ﺍﻟﻜﻭﺩ ﻓﻲ ﺤﺩﺙ ﺍﻟﻨﻘﺭ ﺍﻟﺨﺎﺹ ﺒﺯﺭ ﺍﻷﻤﺭ‪.‬‬
‫ﻜﻴﻑ ﺘﺼل ﺇﻟﻰ ﺍﻟﺤﺩﺙ ﻟﻜﺘﺎﺒﺔ ﺍﻟﻜﻭﺩ‬

‫ﻟﻠﻭﺼﻭل ﺇﻟﻰ ﺍﻟﺤﺩﺙ ﺍﻟﺫﻱ ﻴﻨﻔﺫ ﻋﻨﺩ ﺍﻟﻨﻘﺭ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ‪ .‬ﺍﻓﻌل ﻤﺎ ﻴﻠﻲ ‪:‬‬
‫‪ -١‬ﺃﻀﻑ ﺯﺭ ﺃﻤﺭ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل )‪(٢٤-٢‬‬
‫ﺷﻜﻞ ‪ : ٢٤-٢‬ﺍﻟﻮﺻﻮﻝ ﺇﱃ ﺍﳊﺪﺙ ﺑﺎﻟﻨﻘﺮ ﺍﳌﺰﺩﻭﺝ‬
‫‪ -٢‬ﺍﻨﻘﺭ ﻤﺯﺩﻭﺠﺎ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ ﻟﻴﻅﻬﺭ ﻟﻙ ﺍﻟﺸﻜل )‪ .(٢٥-٢‬ﻴﻤﻜﻥ ﺍﻟﻘﻭل ﺍﻵﻥ ﺃﻨﻙ ﺩﺍﺨل‬
‫ﺍﻟﺤﺩﺙ ﻓﻜل ﻤﺎ ﺴﺘﻜﺘﺒﻪ ﻓﻲ ﻫﺫﺍ ﺍﻹﺠﺭﺍﺀ ﺴﻭﻑ ﻴﻨﻔﺫ ﻋﻨﺩ ﺍﻟﻨﻘﺭ‬
‫ﺸﻜل ‪ : ٢٥- ٢‬ﺒﻌﺩ ﺍﻟﻨﻘﺭ ﺍﻟﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ ﺘﻡ ﺍﻻﻨﺘﻘﺎل ﺇﻟﻰ ﺤﺩﺙ ﺍﻟﻨﻘﺭ ﺍﻟﺨﺎﺹ ﺒﻬﺫﺍ ﺍﻟﺯﺭ‬
‫اﻟﺪوت ﻧﺖ‬
‫ﻧﺖ‬ ‫ﺑﻴﺌﺔ اﻟﺪوت‬
‫ﺗﻘﻮم ﺑﻴﺌﺔ‬
‫ﺗﻘﻮم‬
‫ﻣﻌﻠﻮﻣﺎت‬ ‫ﺑﺎﻧﺸﺎء‬
‫ﺑﺎﻧﺸﺎءﻣﻌﻠﻮﻣﺎت‬
‫اﻟﺤﺪث‬
‫اﻟﺤﺪث‬
‫‪34‬‬
‫ﺷﻜﻞ ‪ : ٢٦-٢‬ﻃﺮﻳﻘﺔ ﺍﻟﻮﺻﻮﻝ ﳊﺪﺙ ﻣﺎ‪.‬‬
‫ﺗﺮﻳﺪ اﻟﻮﺻﻮل‬
‫اﻟﻮﺻﻮل‬ ‫اﻟﺘﻲ ﺗﺮﻳﺪ‬
‫اﻷداة اﻟﺘﻲ‬
‫اﺧﺘﺮ اﻷداة‬
‫اﺧﺘﺮ‬
‫ﻷﺣﺪاﺛﻬﺎ‬ ‫اﺧﺘﺮ اﻟﺤﺪث‬
‫اﻟﺤﺪث‬ ‫اﺧﺘﺮ‬
‫ﻷﺣﺪاﺛﻬﺎ‬
‫ﺗﻜﺒﻴﺮ اﻟﻜﻮد‬
‫اﻟﻜﻮد‬ ‫او ﺗﻜﺒﻴﺮ‬
‫ﺗﺼﻐﻴﺮ او‬
‫ﺗﺼﻐﻴﺮ‬
‫ﻴﻤﻜﻨﻨﺎ ﺘﻘﺴﻴﻡ ﻫﺫﻩ ﺍﻟﺸﺎﺸﺔ ﺇﻟﻰ ﺜﻼﺜﺔ ﺃﻗﺴﺎﻡ ‪:‬‬

‫‪ .I‬ﺍﻟﻘﺴﻡ ﺍﻷﻭل ‪ :‬ﻤﻥ ﺒﺩﺀ ﻋﺒﺎﺭﺓ ‪ Public Class Form1‬ﺇﻟﻰ ﻋﺒﺎﺭﺓ ‪ End Class‬ﻫﺫﺍ‬
‫ﺍﻟﻘﺴﻡ ﻫﻭ ﺍﻟﻔﺌﺔ –‪ -Class‬ﺍﻟﺨﺎﺹ ﺒﺎﻟﻨﻤﻭﺫﺝ‪ .‬ﺤﻴﺙ ﺃﻥ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﺃﺼﺒﺤﺕ‬
‫ﻤﻁﺎﺒﻘﺔ ﻤﺎﺌﺔ ﺒﺎﻟﻤﺎﺌﺔ ﻟﻤﻭﺍﺼﻔﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﺸﻴﺌﻴﺔ ﻓﺈﻥ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺫﻱ ﺃﻨﺸﺄﺘﻪ ﻫﻭ ﻋﺒﺎﺭﺓ‬
‫ﻋﻥ ﻓﺌﺔ ﻭ ﻜل ﻤﺎ ﻴﻨﺩﺭﺝ ﺘﺤﺘﻪ ﻤﻥ ﺃﺩﺍﻭﺕ ﺴﻭﻑ ﺘﺭﺙ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺨﺎﺼﺔ ﺒﺎﻟﻨﻤﻭﺫﺝ‬
‫ﻤﺎ ﻟﻡ ﺘﻘﻡ ﺒﺘﻐﻴﻴﺭﻫﺎ ﻋﻠﻰ ﻤﺴﺘﻭﻯ ﺍﻷﺩﺍﺓ ﻨﻔﺴﻬﺎ‪ .‬ﺒﺎﻟﻁﺒﻊ ﻓﺈﻥ ﺍﻟﻔﺌﺔ ﻟﻠﻨﻤﻭﺫﺝ ﺴﻭﻑ‬
‫ﻴﺤﻭﻱ ﺒﺩﺍﺨﻠﺔ ﻜل ﺘﻌﺭﻴﻔﺎﺕ ﺍﻷﺤﺩﺍﺙ ﻭ ﺨﺼﺎﺌﺼﻬﺎ ﻭ ﺍﻷﺤﺩﺍﺙ ﺍﻟﺨﺎﺼﺔ ﺒﻬﺎ‪.‬‬
‫‪ Private Sub Button1_Click‬إﱃ ‪End Sub‬‬ ‫‪ .II‬ﺍﻟﻘﺴﻡ ﺍﻟﺜﺎﻨﻲ ‪ :‬ﻴﺒﺩﺃ ﻤﻥ ﻜﻠﻤﺔ‬
‫ﻭﻫﺫﺍ ﻫﻭ ﺍﻹﺠﺭﺍﺀ ﺍﻟﺫﻱ ﺃﻨﺸﺄﺘﻪ ﻟﻙ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻟﺘﻘﻭﻡ ﺒﻜﺘﺎﺒﺔ ﺍﻟﻜﻭﺩ ﺩﺍﺨﻠﺔ ﻟﻴﻌﻤل ﻋﻨﺩ ﺍﻟﻨﻘﺭ ﻋﻠﻰ‬
‫ﺯﺭ ﺍﻷﻤﺭ‪ .‬ﺘﻼﺤﻅ ﺃﻥ ﺍﻟﺴﻁﺭ ﺍﻷﻭل ﻁﻭﻴل ﺠﺩﺍ‪ ،‬ﻭﻟﻜﻲ ﺘﺘﻤﻜﻥ ﻤﻥ ﺭﺅﻴﺘﻪ ﻋﻠﻰ ﺍﻟﺸﺎﺸﺔ ﻜﺎﻤﻼ ﺩﻭﻥ ﺃﻥ‬
‫ﺘﻀﻁﺭ ﻻﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﻨﺯﻟﻕ ﺍﻷﻓﻘﻲ ‪ ،Horizontal ScrollBaar‬ﻓﺈﻥ ‪ VB.NET‬ﻴﻤﻨﺤﻙ ﺍﻟﺭﻤﺯ "_ "‬
‫ﺍﻟﺫﻱ ﻫﻭ ﻋﺒﺎﺭﺓ ﻋﻥ ﻤﺴﺎﻓﺔ ﻭﺸﺭﻁﺔ ﻤﻨﺨﻔﻀﺔ ‪ ،Underscore‬ﻭﺍﻟﺫﻱ ﺒﺈﻀﺎﻓﺘﻪ ﻟﻨﻬﺎﻴﺔ ﺍﻟﺴﻁﺭ‪ ،‬ﻴﻌﺘﺒﺭ‬
‫‪ VB.NET‬ﺃﻥ ﺍﻟﺴﻁﺭ ﻟﻡ ﻴﻨﺘ ِﻪ ﺒﻌﺩ‪ ،‬ﻭﺃﻥ ﺍﻟﺴﻁﺭ ﺍﻟﺫﻱ ﻴﻠﻴﻪ ﻫﻭ ﻤﻜﻤل ﻟﻪ‪ .‬ﻭﺒﻬﺫﺍ ﻴﻤﻜﻨﻙ ﺃﻥ ﺘﺸﻁﺭ‬
‫ﺍﻷﺴﻁﺭ ﺍﻟﻁﻭﻴﻠﺔ ﺇﻟﻰ ﻋﺩﺓ ﺃﺴﻁﺭ‪ ،‬ﺩﻭﻥ ﺃﻥ ﺘﺘﺴﺒﺏ ﻓﻲ ﺨﻁﺄ ﻓﻲ ﻗﻭﺍﻋﺩ ﺍﻟﻠﻐﺔ ‪ .Syntax‬ﻭﻫﻨﺎﻙ‬
‫ﻁﺭﻴﻘﺔ ﺃﺨﺭﻯ ﻭﻫﻲ ﺘﺠﺯﻱﺀ ﺍﻟﺠﻤل ﺍﺭﺠﻊ ﺇﻟﻰ ﻤﻤﻴﺯﺍﺕ ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ ﻟﻤﻌﺭﻓﺔ ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﻭﺘﻌﺘﺒﺭ‬
‫ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﺃﺴﻬل ﻤﻥ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻷﻭﻟﻰ‪.‬‬
‫‪35‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻋﻨﺩ ﺍﻟﻨﻘﺭ ﺍﻟﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺃﻴﺔ ﺃﺩﺍﺓ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻓﺈﻥ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﺴﻭﻑ ﺘﻘﻭﺩﻙ‬
‫ﺇﻟﻰ ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ ﻭ ﺘﻀﻌﻙ ﻓﻲ ﺍﻟﺤﺩﺙ ﺍﻟﺨﺎﺹ ﺒﺘﻠﻙ ﺍﻷﺩﺍﺓ‬
‫‪-III‬ﺍﻟﻘﺴﻡ ﺍﻟﺜﺎﻟﺙ ‪ :‬ﻭﻫﻭ ﻋﺒﺎﺭﺓ ‪Windows Form Designer generated code‬‬
‫ﻭﻴﻭﺠﺩ ﺃﻤﺎﻤﻪ ﻋﻼﻤﺔ ﺯﺍﺌﺩ ‪ +‬ﻟﻭ ﻀﻐﻁﺕ ﻋﻠﻴﻬﺎ ﻟﻅﻬﺭ ﻟﻙ ﺤﺠﻡ ﻜﺒﻴﺭ ﻤﻥ ﺍﻟﻌﺒﺎﺭﺍﺕ‪ .‬ﻫﺫﻩ ﺍﻟﻤﻨﻁﻘﺔ‬
‫ﻫﻲ ﻤﺎ ﻴﺴﻤﻰ ﺒﺎﻟﻜﻭﺩ ﺍﻟﻤﻨﺘﺞ ﻤﻥ ﻗﺒل ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻭﻴﺤﻭﻱ ﻋﺩﺓ ﺃﺸﻴﺎﺀ ﻤﻨﻬﺎ ‪:‬‬
‫ﺸﺭﺤﻬﺎ‬ ‫اﻟﻌﺒﺎرة‬
‫ﻻﻜﺘﺴﺎﺏ ﺍﻟﻤﻌﺎﻟﻡ ﺍﻷﺴﺎﺴﻴﺔ ﻟﻠﻨﻤﻭﺫﺝ ﻤﻥ‬ ‫‪Inherits System.WinForms.Form‬‬
‫‪ WinForms.Form‬ﻭﻤﻌﻨﻰ ﺫﻟﻙ ﺃﻥ ﻫﺫﺍ‬
‫ﺍﻟﻨﻤﻭﺫﺝ ‪ Form1‬ﻗﺎﺌﻡ ﻭﻤﻌﺘﻤﺩ ﻭﻤﻜﺘﺴﺏ‬
‫ﻟﻠﺨﺼﺎﺌﺹ ﺍﻷﺴﺎﺴﻴﺔ ﻟـ‪WinForms.Form‬‬
‫ﻭﺒﺩﻭﻥ ﻫﺫﻩ ﺍﻟﺠﻤﻠﺔ ﻻ ﻴﻤﻜﻥ ﺃﻥ ﻴﻌﻤل ﺍﻟﻨﻤﻭﺫﺝ‪.‬‬
‫ﻴﺘﻡ ﺘﻨﻔﻴﺫ ﻫﺫﺍ ﺍﻹﺠﺭﺍﺀ ﻋﻨﺩ ﺒﺩﺀ ﺘﺤﻤﻴل‬
‫)(‪Public Sub New‬‬
‫)(‪MyBase.New‬‬
‫ﺍﻟﻨﻤﻭﺫﺝ‪ .‬ﻭﻫﻭ ﻴﺤل ﻤﺤل ‪Form_Intialize‬‬ ‫‪'This call is required by‬‬
‫‪the Windows Form Designer.‬‬
‫ﻭﺍﻟﺘﻲ ﻜﺎﻨﺕ ﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻹﺼﺩﺍﺭ ﺍﻟﺴﺎﺒﻕ ﻤﻥ‬ ‫)(‪InitializeComponent‬‬
‫ﻓﻴﺠﻭﺍل ﺒﻴﺴﻙ‪ .‬ﺇﺫﺍ ﺃﺭﺩﺕ ﻋﻤل ﺸﻲﺀ ﻤﺎ ﻓﻲ‬ ‫‪'Add any initialization‬‬
‫‪after‬‬ ‫)(‪the InitializeComponent‬‬
‫ﺒﺩﺍﻴﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻓﺎﻜﺘﺒﻪ ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺫﻱ ﻴﻠﻲ ﺩﺍﻟﺔ‬ ‫‪call‬‬
‫)(‪.InitializeComponent‬‬ ‫‪End Sub‬‬
‫ﻴﺘﻡ ﺘﻨﻔﻴﺫ ﻫﺫﺍ ﺍﻹﺠﺭﺍﺀ ﻋﻨﺩ ﺇﻨﻬﺎﺀ ﺍﻟﺒﺭﻨﺎﻤﺞ‪.‬‬

‫‪Protected Overloads Overrides Sub‬‬
‫‪Dispose(ByVal‬‬ ‫‪disposing‬‬ ‫‪As‬‬
‫)‪Boolean‬‬
‫ﻴﻘﻭﻡ ﻫﺫﺍ ﺍﻹﺠﺭﺍﺀ ﺒﺈﺯﺍﻟﺔ ﻜل ﻤﺎ ﻴﺘﻌﻠﻕ‬ ‫‪If disposing Then‬‬
‫‪If Not (components Is‬‬
‫ﺒﺎﻟﺒﺭﻨﺎﻤﺞ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ‪ .‬ﻫﺫﺍ ﺍﻹﺠﺭﺍﺀ ﺤل ﻤﺤل‬ ‫‪Nothing) Then‬‬
‫‪ Form_Terminate‬ﻭ ﺍﻟﺫﻱ ﻜﺎﻥ ﻤﻭﺠﻭﺩﺍ‬ ‫)(‪components.Dispose‬‬

‫‪End If‬‬
‫ﻓﻲ ﺍﻹﺼﺩﺍﺭ ﺍﻟﺴﺎﺩﺱ‪.‬‬ ‫‪End If‬‬
‫)‪MyBase.Dispose(disposing‬‬
‫‪End Sub‬‬
‫)(‪ Private Sub InitializeComponent‬ﻫﺫﺍ ﺍﻹﺠﺭﺍﺀ ﻤﻬﻡ ﺠﺩﺍ ﻭﻫﻭ ﺇﺠﺭﺍﺀ ﻴﺤﻔﻅ ﻜل‬
‫‪Me.Button1‬‬ ‫=‬ ‫‪New‬‬
‫ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﻲ ﻏﻴﺭﺘﻬﺎ ﺃﺜﻨﺎﺀ ﺘﺼﻤﻴﻡ ﺍﻟﻨﻤﻭﺫﺝ‬ ‫)(‪System.Windows.Forms.Button‬‬
‫إﻟﻰ ﻧﻬﺎﻳﺔ هﺬا اﻹﺟﺮاء‬
‫‪.‬ﻟﻜﻥ ﻻ ﺘﺤﺎﻭل ﺘﻌﺩﻴل ﺍﻟﺨﺼﺎﺌﺹ ﻤﻥ ﻫﻨﺎ ‪.‬‬ ‫‪End Sub‬‬
‫‪36‬‬
‫ﻭﻤﻥ ﻓﻭﺍﺌﺩ ﻫﺫﺍ ﺍﻹﺠﺭﺍﺀ ﺃﻨﻪ ﻴﻤﻜﻨﻙ ﺘﺼﻤﻴﻡ‬

‫ﻨﻤﻭﺫﺝ ﺒﺎﻟﻁﺭﻴﻘﺔ ﺍﻟﺘﻲ ﺘﺭﻴﺩﻫﺎ ﺜﻡ ﻨﺴﺦ ﻫﺫﺍ‬
‫ﺍﻹﺠﺭﺍﺀ ﻭﻭﻀﻌﻪ ﻓﻲ ﻨﻤﺎﺫﺝ ﺃﺨﺭﻯ ﻤﺜل ﻨﻤﺎﺫﺝ‬
‫ﺍﻹﻨﺘﺭﻨﺕ ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﺃﻨﺼﺢ ﺒﻌﺩﻡ ﻤﺤﺎﻭﻟﺔ ﺘﻌﺩﻴل ﺍﻟﻘﺴﻡ ﺍﻟﺜﺎﻟﺙ ﻭ ﺍﻟﺫﻱ ﻴﻤﺜل ﺍﻟﻜﻭﺩ ﺍﻟﻤﻨﺘﺞ ﺇﻻ ﺇﺫﺍ ﻜﻨﺕ ﻋﻠﻰ‬
‫ﺩﺭﺍﻴﺔ ﺘﺎﻤﺔ ﺒﻤﺎ ﺘﻌﻤل‪.‬‬
‫‪37‬‬
‫ﻤﻘﺩﻤﺔ ﻟﻤﻌﺎﻟﺠﺔ ﺍﻷﺨﻁﺎﺀ‬

‫ﻋﻨﺩ ﺍﻜﺘﻤﺎل ﺃﻱ ﺒﺭﻨﺎﻤﺞ ﻓﺈﻥ ﻫﻨﺎﻙ ﻋﺩﺩ ﻤﻥ ﺍﻷﺨﻁﺎﺀ ﺍﻟﻤﺘﻭﻗﻌﺔ ﻭ ﻏﻴﺭ ﺍﻟﻤﺘﻭﻗﻌﺔ ﻗﺩ ﺘﺤﺙ ﻓﻲ ﺍﻟﻨﻅﺎﻡ‬
‫ﺃﺜﻨﺎﺀ ﻋﻤﻠﻪ‪ .‬ﻤﻬﻤﺎ ﺒﻠﻎ ﺍﺤﺘﺭﺍﻑ ﺍﻟﻤﺒﺭﻤﺞ ﻓﺈﻨﻪ ﻟﻥ ﻴﺴﺘﻁﻴﻊ ﺃﻥ ﻴﺨﻠﻲ ﺒﺭﻨﺎﻤﺠﻪ ﻤﻥ ﺍﻷﺨﻁﺎﺀ‪ .‬ﻤﻥ ﺍﻟﺠﺩﻴﺭ‬
‫ﺒﺎﻟﺫﻜﺭ ﻫﻨﺎ ﺫﻜﺭ ﺃﻨﻭﺍﻉ ﺍﻷﺨﻁﺎﺀ ﺒﺼﻔﺔ ﻋﺎﻤﺔ‪ ،‬ﻴﻤﻜﻥ ﺘﻘﺴﻴﻡ ﺃﻨﻭﺍﻉ ﺍﻷﺨﻁﺎﺀ ﺇﻟﻰ ﺜﻼﺜﺔ ﺃﻗﺴﺎﻡ ﻭﻫﻲ ‪:‬‬
‫‪ -١‬ﺍﻷﺨﻁﺎﺀ ﺍﻟﺒﻨﺎﺌﻴﺔ ‪ :‬ﻭﻫﻭ ﺍﻟﻨﻭﻉ ﺍﻟﺸﺎﺌﻊ ﻤﻥ ﺍﻷﺨﻁﺎﺀ ﻭﻴﺤﺼل ﻋﻨﺩ ﻜﺘﺎﺒﺔ ﻋﺒﺎﺭﺓ ﻓﻲ ﺍﻟﻜﻭﺩ‬
‫ﺒﺼﻴﻐﺔ ﺘﺨﺎﻟﻑ ﻗﻭﺍﻋﺩ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ‪ .‬ﻭﻴﻤﻜﻥ ﺍﻟﺘﻤﺜﻴل ﻟﻬﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻷﺨﻁﺎﺀ ﺒﻤﺜﺎﻟﻴﻥ ‪:‬‬
‫‪ .a‬ﺍﻟﺨﻁﺄ ﺍﻹﻤﻼﺌﻲ ﻓﻲ ﻜﺘﺎﺒﺔ ﺩﺍﻟﺔ ﻤﺎ; ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ‬
‫‪Dim a As String‬‬
‫‪Dim b As Integer‬‬
‫)‪ctyp(a, b‬‬
‫ﻻﺤﻅ ﺍﻟﺨﻁﺄ ﺍﻹﻤﻼﺌﻲ ﻓﻲ ﺩﺍﻟﺔ ‪ ctype‬ﺤﻴﺙ ﻟﻡ ﻨﻜﺘﺏ ﺤﺭﻑ ‪ e‬ﻓﻲ ﺁﺨﺭ ﺍﻟﺩﺍﻟﺔ‪.‬‬
‫‪ .b‬ﻓﻘﺩﺍﻥ ﺠﺯﺀ ﻤﻥ ﺍﻟﺠﻤل ﺍﻟﻤﺭﻜﺒﺔ ﻤﺜل ‪:‬‬
‫‪Dim a As Integer‬‬
‫‪If a > 10 Then‬‬
‫‪a = a + 10‬‬
‫ﻻﺤﻅ ﺍﻟﺨﻁﺄ ﻭﻫﻭ ﻨﺴﻴﺎﻥ ﺠﻤﻠﺔ ‪ end if‬ﻭ ﺍﻟﺘﻲ ﻴﻔﺘﺭﺽ ﺃﻥ ﺘﺄﺘﻲ ﺒﻌﺩ ﻨﻬﺎﻴﺔ ﺠﻤﻠﺔ ‪.If‬‬
‫ﻋﻨﺩ ﻭﺠﻭﺩ ﺨﻁﺄ ﺒﻨﺎﺌﻲ ﻓﺈﻥ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﺘﻅﻬﺭ ﺨﻁﺎ ﻤﺘﻌﺭﺠﺎ ﺘﺤﺕ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺘﻲ ﻴﻜﻤﻥ ﻓﻴﻬﺎ‬
‫ﺍﻟﺨﻁﺄ ﻭﺘﻅﻬﺭ ﻫﺫﻩ ﺍﻷﺨﻁﺎﺀ ﻓﻲ ﻨﺎﻓﺫﺓ ﺍﻟﻤﻬﺎﻡ ﻋﻨﺩ ﻤﺤﺎﻭﻟﺔ ﺇﻨﺘﺎﺝ ﺍﻟﻨﻅﺎﻡ‪.‬‬
‫‪ -٢‬ﺍﻷﺨﻁﺎﺀ ﺍﻟﺘﺸﻐﻴﻠﻴﺔ ‪ :‬ﻭﻴﺤﺼل ﻫﺫﺍ ﺍﻟﺨﻁﺄ ﻋﻨﺩ ﻤﺤﺎﻭﻟﺔ ﺘﻨﻔﻴﺫ ﺠﻤﻠﺔ ﻤﻥ ﺍﻟﻤﺴﺘﺤﻴل ﺘﻨﻔﻴﺫﻫﺎ‪.‬ﻭ‬
‫ﻻ ﻴﻅﻬﺭ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻷﺨﻁﺎﺀ ﺇﻻ ﺒﻌﺩ ﺘﻨﻔﻴﺫ ﺍﻟﻨﻅﺎﻡ‪.‬ﻜﻤﺎ ﺍﻨﻪ ﻻ ﻴﻤﻜﻥ ﺍﻜﺘﺸﺎﻑ ﻫﺫﻩ‬
‫ﺍﻷﺨﻁﺎﺀ ﻋﻨﺩ ﺇﻨﺘﺎﺝ ﺍﻟﻨﻅﺎﻡ ﻭﻟﻌل ﺃﺒﺭﺯ ﺍﻷﻤﺜﻠﺔ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻫﻭ ﻤﺤﺎﻭﻟﺔ ﺍﻟﻘﺴﻤﺔ ﻋﻠﻰ‬
‫ﺼﻔﺭ ﻭﻫﺎﻙ ﻤﺜﺎل ﺁﺨﺭ ﻤﺎﺫﺍ ﻟﻭ ﺤﺎﻭل ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻻﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﻜﻥ ﺍﻟﺨﺎﺩﻡ ﺍﻟﺫﻱ‬
‫ﺘﻭﺠﺩ ﻓﻴﻪ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻜﺎﻥ ﻻ ﻴﻌﻤل ﻟﺴﺒﺏ ﺃﻭ ﻵﺨﺭ ﻓﺈﻥ ﻫﺫﺍ ﺍﻟﺨﻁﺄ ﻫﻭ ﺨﻁﺄ ﺘﺸﻐﻴﻠﻲ‬
‫ﺒﺤﺕ‪.‬ﻭ ﻋﻨﺩ ﻋﺩﻡ ﻤﻌﺎﻟﺠﺔ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻷﺨﻁﺎﺀ ﻗﺩ ﻴﺘﻭﻗﻑ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺒﻌﺩ ﺤﺩﻭﺙ ﺍﻟﺨﻁﺄ‪.‬‬
‫ﻴﺘﻡ ﻤﻌﺎﻟﺠﺔ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻷﺨﻁﺎﺀ ﻤﻥ ﺨﻼل ﻋﺒﺎﺭﺓ ‪.Try Catch‬‬
‫‪38‬‬
‫‪ -٣‬ﺍﻷﺨﻁﺎﺀ ﺍﻟﻤﻨﻁﻘﻴﺔ ‪ :‬ﺘﻌﺘﺒﺭ ﻤﻥ ﺍﻷﺨﻁﺎﺀ ﺍﻟﺘﻲ ﻴﺼﻌﺏ ﺇﻴﺠﺎﺩﻫﺎ ﻭ ﻴﺤﺩﺙ ﻋﻨﺩﻤﺎ ﻻ ﻴﺅﺩﻱ‬
‫ﺍﻟﻨﻅﺎﻡ ﻨﺘﺎﺌﺠﻪ ﻜﻤﺎ ﻴﻨﺒﻐﻲ‪ .‬ﺍﻨﻅﺭ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫‪Dim a As Integer‬‬
‫‪a = 5‬‬
‫‪Do While a < 5‬‬
‫‪a = a - 5‬‬
‫‪Loop‬‬
‫ﻻﺤﻅ ﺃﻥ ﻫﺫﺍ ﺍﻟﺘﻜﺭﺍﺭ ﻟﻥ ﻴﻨﺘﻬﻲ‪.‬‬
‫ﻴﺘﻡ ﻤﻌﺎﻟﺠﺔ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻷﺨﻁﺎﺀ ﺒﻤﺭﺍﺠﻌﺔ ﺍﻟﻜﻭﺩ ﻴﺩﻭﻴﺎ ﻤﻥ ﻗﺒل ﺍﻟﻤﺒﺭﻤﺞ ﻭ ﺍﻜﺘﺸﺎﻑ ﺍﻟﺨﻁﺄ‬
‫ﺒﻨﻔﺴﻪ‪.‬‬
‫‪39‬‬
‫ﺍﻟﺩﺭﺱ ﺍﻷﻭل‬
‫ﺍﻟﻬﺩﻑ ‪ :‬ﺴﻭﻑ ﺘﻜﻭﻥ ﺒﺩﺍﻴﺔ ﺍﻟﺘﻌﺎﻤل ﺍﻟﺤﻘﻴﻘﻲ ﻤﻊ ﺒﻴﺌﺔ ‪ vb.net‬ﻤﻤﺎ ﻴﻜﻭﻥ ﻟﻪ ﺍﻟﺩﻭﺭ ﻓﻲ ﺇﺯﺍﻟﺔ‬
‫ﺍﻟﺤﺎﺠﺯ ﺍﻟﻨﻔﺴﻲ ﻭﻴﻤﻜﻨﻙ ﻤﻥ ﺍﻟﺘﻌﻠﻡ ﻋﻠﻰ ﺃﺴﺎﺴﻴﺎﺕ ﻫﺫﻩ ﺍﻟﺒﻴﺌﺔ ﺍﻟﺒﺭﻤﺠﻴﺔ‪.‬‬
‫ﻤﺎﺫﺍ ﺴﻴﻨﺘﺞ ‪ . :‬ﺒﻌﺩ ﻨﻘﺭ ﺯﺭ ﺍﻷﻤﺭ ﺒﺎﻟﻔﺄﺭﺓ ﺴﻭﻑ ﺘﻅﻬﺭ ﻟﻨﺎ " ﻤﺭﺤﺒﺎ ﺒﻜﻡ ﻓﻲ ﺒﺭﻨﺎﻤﺠﻲ ﺍﻷﻭل‬
‫" ﻋﻠﻰ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ‬
‫ﺍﻷﺩﻭﺍﺕ ‪ :‬ﺴﻭﻑ ﻴﻜﻭﻥ ﻟﺩﻴﻨﺎ ﻨﻤﻭﺫﺝ ﻭﻋﻠﻴﻪ ﺯﺭ ﺃﻤﺭ ﻭﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ‬
‫ﺍﻟﺸﺭﺡ ﺍﻟﺘﻔﺼﻴﻠﻲ‬ ‫ﺍﻟﺨﻁﻭﺓ‬

‫‪ -١‬ﻭﻀﻊ ﺍﻷﺩﺍﻭﺕ ‪ -١‬ﻀﻊ ﺯﺭ ﺃﻤﺭ ﻭﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ‪ Form1‬ﻜﻤﺎ ﻫﻭ ﻤﻭﻀﺢ‬
‫ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺒﺎﻟﺸﻜل )‪.(٢٧-٢‬‬
‫ﺸﻜل ‪ : ٢٧-٢‬ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ ﻭﺯﺭ ﺃﻤﺭ‬
‫ﻤﻥ ﺨﻼل ‪Edit Î Advance Î Word Wrapping‬‬ ‫‪ -٢‬ﺘﺠﺯﺉ ﺍﻟﺠﻤل‬
‫‪40‬‬
‫ﻏﻴﺭ ﺨﺼﺎﺌﺹ ﺍﻷﺩﻭﺍﺕ ﻟﺘﺼﺒﺢ ﻤﻁﺎﺒﻘﺔ ﻟﻠﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ‪:‬‬ ‫‪ -٣‬ﺘﻐﻴﻴﺭ‬

‫ﺨﺼﺎﺌﺹ ﺒﻌﺽ‬
‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﻴﺔ‬ ‫ﺍﺴﻡ ﺍﻷﺩﺍﺓ‬ ‫ﺍﻷﺩﻭﺍﺕ‬
‫‪CmdWelcome‬‬ ‫‪Name‬‬ ‫‪Button1‬‬
‫ﻤﺭﺤﺒﺎ‬ ‫‪Text‬‬
‫‪LblHello‬‬ ‫‪Name‬‬ ‫‪Label1‬‬
‫‪Text‬‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻷﻭل‬ ‫‪Text‬‬ ‫‪Form1‬‬
‫‪Yes‬‬ ‫‪RightToLeft‬‬
‫‪.cmdWelcome‬‬ ‫‪ -١‬ﺍﻨﻘﺭ ﻤﺭﺘﻴﻥ ﻤﺘﺘﺎﻟﻴﺘﻴﻥ ﺒﺎﻟﻔﺄﺭﺓ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ‬ ‫‪ -٤‬ﺘﻐﻴﻴﺭ ﺨﺎﺼﻴﺔ‬

‫‪ Text‬ﺴﻭﻑ ﺘﻅﻬﺭ ﻟﻙ ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ ﻭﺴﻭﻑ ﻴﻜﻭﻥ ﺍﻟﻤﺅﺸﺭ ﺒﻴﻥ ﺍﻟﺴﻁﺭﻴﻥ‬ ‫ﻷﺩﺍﺓ‬
‫ﺍﻟﻌﻨﻭﺍﻥ ﻋﻨﺩ ﺤﺩﺙ ﺍﻟﺘﺎﻟﻴﻴﻥ‬
‫ﺍﻟﻨﻘﺭ ﻟﺯﺭ ﺍﻷﻤﺭ‪.‬‬
‫‪ -٢‬ﺍﻜﺘﺏ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺒﻴﻥ ﺍﻟﺴﻁﺭﻴﻥ ﺍﻟﺴﺎﺒﻘﻴﻥ‬

‫"ﻤﺭﺤﺒﺎ ﺒﻜﻡ ﻓﻲ ﺒﺭﻨﺎﻤﺠﻲ ﺍﻷﻭل" = ‪lblHello.Text‬‬
‫‪41‬‬
‫‪ -٤‬ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ‪ -١‬ﺍﺭﺠﻊ ﺇﻟﻰ ﺸﺎﺸﺔ ﺍﻟﺘﺼﻤﻴﻡ ﻭﺫﻟﻙ ﺒﺎﻟﻨﻘﺭ ﺍﻟﻤﺯﺩﻭﺝ ﻋﻠﻰ ‪Form1.vb‬‬
‫ﻭﻤﻼﺤﻅﺔ ﺘﻐﻴﺭ ﺃﺩﺍﺓ ﻓﻲ ﺍﻟﻤﺴﺘﻜﺸﻑ ﺃﻭ ﺍﻟﻨﻘﺭ ﻋﻠﻰ ﺸﺭﻴﻁ *]‪ Form1.vb[Design‬ﻓﻲ ﺃﻋﻠﻰ‬
‫ﺍﻟﻌﻨﻭﺍﻥ ﻋﻨﺩ ﺍﻟﻨﻘﺭ ﺸﺎﺸﺔ ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ‪.‬‬
‫ﺃﻭ ﺍﺨﺘﺭ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ‪ Debug‬ﺜﻡ‬ ‫ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ‪ -٢ ،‬ﻟﺘﺸﻐﻴل ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻀﻐﻁ ‪F5‬‬
‫ﻭ ﺒﻤﻌﻨﻰ ﺁﺨﺭ ﺃﻥ ‪.Start‬‬
‫ﺍﻟﺤﺩﺙ ‪– Click‬‬
‫ﺍﻨﻅﺭ‬ ‫‪ -٣‬ﺍﻨﻘﺭ ﻋﻠﻰ ﺯﺭ ﻤﺭﺤﺒﺎ ﺜﻡ ﻻﺤﻅ ﺘﻐﻴﺭ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ‬
‫ﺘﻨﻔﻴﺫﻩ‬ ‫ﺘﻡ‬ ‫ﺍﻟﻨﻘﺭ‪-‬‬
‫ﺍﻟﺸﻜل )‪.(٢٨-٢‬‬
‫ﻋﻨﺩ ﺍﻟﻨﻘﺭ ﻋﻠﻰ ﺯﺭ‬
‫ﺸﻜل ‪ : ٢٨-٢‬ﻅﻬﻭﺭ " ﻤﺭﺤﺒﺎ ﺒﻜﻡ ﻓﻲ ﺒﺭﻨﺎﻤﺠﻲ ﺍﻷﻭل‬ ‫ﺍﻷﻤﺭ‪.‬‬
‫" ﺒﻌﺩ ﺍﻟﻨﻘﺭ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ ﻤﺭﺤﺒﺎ‬
‫‪42‬‬
‫ﺧﺎﻟﺪ ﺍﳉﺪﻳﻊ ‪kal_judaia@hotmail.com‬‬
‫ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ‬
‫ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﺘﺴﺘﺨﺩﻡ ﻟﻌﺭﺽ ﺍﻟﻨﺼﻭﺹ ﺍﻟﺘﻲ ﻻ ﻴﺭﻏﺏ ﺃﻥ ﻴﺤﺭﺭﻫﺎ ﺍﻟﻤﺴﺘﺨﺩﻡ‪ .‬ﻓﻲ ﺍﻟﻌﺎﺩﺓ ﺘﺴﺘﺨﺩﻡ‬
‫ﻋﻨﻭﺍﻨﺎ ﻷﺩﻭﺍﺕ ﺃﺨﺭﻯ‪.‬‬
‫ﻋﻨﺩﻤﺎ ﻴﻜﻭﻥ ﻋﻨﺩﻙ ﻤﺭﺒﻊ ﻨﺹ ﻹﺩﺨﺎل ﺍﺴﻤﺎﺀ ﺍﻟﻁﻼﺏ ﺍﺴﺘﺨﺩﻡ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ﻟﺘﻜﻭﻥ‬ ‫ﻤﺜﺎل‬
‫ﺷﻜﻞ ‪ ١ -٥‬ﺍﺳﺘﺨﺪﺍﻡ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻮﺍﻥ‬ ‫ﻋﻨﻭﺍﻨﺎ ﻟﻬﺫﺍ ﺍﻟﻤﺭﺒﻊ ﻜﻤﺎ ﻓﻲ ﺍﻟﺸﻜل)‪(١-٥‬‬
‫ﺨﺼﺎﺌﺹ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ‬
‫‪ .١‬ﺨﺎﺼﻴﺔ ﺍﻻﺴﻡ ‪ :‬ﺍﺴﻡ ﻟﻸﺩﺍﺓ ﻤﻊ ﻤﻼﺤﻅﺔ ﺃﻨﻪ ﻻﻴﻤﻜﻥ ﺃﻥ ﺘﻭﺠﺩ ﺃﺩﺍﺘﻴﻥ ﻋﻠﻰ ﻨﻔﺱ ﺍﻟﻨﺎﻓﺫﺓ ﺒﻨﻔﺱ‬
‫ﺍﻻﺴﻡ‪.‬‬
‫ﺍﻟﺸﺭﺡ‬ ‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﻴﺔ‬

‫ﻫﺫﻩ ﻫﻭ ﺍﺴﻡ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ﻭﻫﻭ ﻤﺎﺘﺴﺘﺨﺩﻤﻪ ﺇﺫﺍ ﺃﺭﺩﺕ‬ ‫‪Name‬‬
‫ﺍﻟﻭﺼﻭل ﻟﻠﺨﺼﺎﺌﺹ ﺒﺭﻤﺠﻴﺎ‪.‬‬
‫‪٦٦‬‬
‫‪ .٢‬ﺍﻟﻤﺭﺴﺎﺓ ﺃﻭ ﺍﻟﻤﺜﺒﺘﺔ ‪ :‬ﻫﻲ ﺨﺎﺼﻴﺔ ﺠﺩﻴﺩﺓ ﺘﺴﺘﺨﺩﻡ ﻟﻠﻤﺤﺎﻓﻅﺔ ﻋﻠﻰ ﻤﻭﺍﻗﻊ ﺍﻷﺩﻭﺍﺕ ﻓﻲ ﺍﻟﻨﺎﻓﺫﺓ‬
‫ﻋﻨﺩ ﺘﻐﻴﻴﺭ ﺤﺠﻤﻬﺎ‪.‬‬
‫ﻤﺜﺎل ‪ :‬ﺇﺫﺍ ﺍﺨﺘﺭﻨﺎ ﺍﻟﺠﻬﺔ ﺍﻟﻴﻤﻨﻰ )ﺸﻜل ‪ (٢-٥‬ﻤﻥ ﻫﺫﻩ‬ ‫ﺠﻤﻴﻊ ﺍﻟﺠﻬﺎﺕ ﻤﺜل‬ ‫‪Anchor‬‬
‫ﺍﻟﺨﺎﺼﻴﺔ ﻓﺈﻥ ﺍﻟﻤﺴﺎﻓﺔ ﺒﻴﻥ ﻫﺫﺍ ﺍﻟﻜﺎﺌﻥ ﻭ ﺍﻟﻜﺎﺌﻥ ﺍﻟﺤﺎﻭﻱ‬ ‫ﻴﻤﻴﻥ ﺃﻭ ﻴﺴﺎﺭ ﺃﻭ‬
‫ﻟﻪ ﻤﻥ ﺍﻟﺠﻬﺔ ﺍﻟﻴﻤﻨﻰ ﺴﻭﻑ ﺘﺒﻘﻰ ﻜﻤﺎ ﻫﻲ ﺴﻭﺍﺀ‬ ‫ﻴﻤﻴﻥ ﻓﻭﻕ ﺃﻭ‬
‫ﺼﻐﺭﻨﺎ ﺍﻟﻜﺎﺌﻥ ﺍﻟﺤﺎﻭﻱ ﺃﻭ ﻜﺒﺭﻨﺎﻩ‪ .‬ﻓﻲ ﺍﻟﺸﻜل)‪(٣-٥‬‬ ‫ﻴﺴﺎﺭ ﺃﺴﻔل‬
‫ﻟﻤﺎ ﺍﺨﺘﺭﻨﺎ ﺍﻟﺠﻬﺔ ﺍﻟﻴﻤﻨﻰ ﻤﻥ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺒﻘﻴﺕ‬
‫ﺍﻟﻤﺴﺎﻓﺔ ﻜﻤﺎ ﻫﻲ ﺒﻴﻥ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ﻭﺤﺩ ﺍﻟﻨﻤﻭﺫﺝ –‬
‫ﺍﻟﻜﺎﺌﻥ ﺍﻟﺤﺎﻭﻱ‪ -‬ﺍﻷﻴﻤﻥ‬
‫ﺷﻜﻞ ‪ ٣-٥‬ﻛﻤﺎ ﺗﻼﺣﻆ ﺍﳌﺴﺎﻓﺔ ﺑﲔ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻮﺍﻥ ﻭ ﺍﳊﺪ ﺍﻷﳝﻦ ﻟﻠﻨﻤﻮﺫﺝ ﱂ ﺗﺘﻐﲑ‬ ‫ﺷﻜﻞ ‪٢-٥‬ﻛﻤﺎ ﺗﺮﻯ ﺍﺧﺘﺮﻧﺎ ﺍﳉﻬﺔ ﺍﻟﻴﻤﲎ‬
‫‪ .٣‬ﺍﻟﺤﺠﻡ ﺍﻟﺘﻠﻘﺎﺌﻲ ‪ :‬ﺘﺴﺘﺨﺩﻡ ﻋﻨﺩﻤﺎ ﺘﻜﻭﻥ ﻏﻴﺭ ﻤﺘﺄﻜﺩ ﻤﻥ ﻁﻭل ﺍﻟﻨﺹ ﺍﻟﺫﻱ ﺴﻴﻌﺭﺽ ﻋﻠﻰ ﺃﺩﺍﺓ‬
‫ﺍﻟﻌﻨﻭﺍﻥ‪ .‬ﺍﺠﻌﻠﻬﺎ ‪ True‬ﻟﺘﻤﺘﺩ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ﻤﻊ ﺍﻟﻨﺹ ﻁﻭﻻ ﻭ ﻗﺼﺭﺍ ﻭﻫﻲ ﻤﺘﻭﻓﺭﺓ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ‬
‫ﻭﺍﻟﺘﻨﻔﻴﺫ‪ .‬ﻤﺜﺎل ﻟﻭ ﺃﺭﺩﺕ ﺃﻥ ﺘﻐﻴﺭ ﻗﻴﻤﺘﻬﺎ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ﻷﺩﺍﺓ ‪Label1‬‬
‫‪Label1.Autosize = True‬‬

‫ﻴﺘﻐﻴﺭ ﺍﻟﺤﺠﻡ ﺒﻨﺎﺀ ﻋﻠﻰ ﺍﻟﻨﺹ ﻁﻭﻻ ﻭﻗﺼﺭﺍ‪.‬‬ ‫‪True‬‬ ‫‪Autosize‬‬
‫ﻫﻲ ﺍﻟﻘﻴﻤﺔ ﺍﻹﻓﺘﺭﺍﻀﻴﺔ‪ .‬ﺴﻭﻑ ﻴﺒﻘﻰ ﺤﺠﻡ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ‬ ‫‪False‬‬
‫)ﻁﻭﻟﻬﺎ ﻭﻋﺭﻀﻬﺎ( ﺜﺎﺒﺘﺎ ﻜﻤﺎ ﺘﻡ ﺘﺤﺩﻴﺩﻩ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ‪.‬‬
‫‪ .٤‬ﻟﻭﻥ ﺍﻟﺨﻠﻔﻴﺔ ‪ :‬ﻴﻤﻜﻥ ﺘﻐﻴﻴﺭ ﻟﻭﻥ ﺍﻟﺨﻠﻔﻴﺔ ﻟﻸﺩﺍﺓ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﻭﺍﻟﺘﻨﻔﻴﺫ‪.‬‬
‫‪٦٧‬‬

‫ﺘﻤﻜﻨﻙ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻤﻥ ﺘﻐﻴﻴﺭ ﺍﻟﻠﻭﻥ ﺍﻟﺨﻠﻔﻲ ﻷﺩﺍﺓ‬ ‫‪Backcolor‬‬
‫ﺍﻟﻌﻨﻭﺍﻥ‬
‫ﻤﺜﺎل ﻟﺘﻐﻴﻴﺭ ﻟﻭﻥ ﺍﻟﺨﻠﻔﻴﺔ ﻷﺩﺍﺓ ﻋﻨﻭﺍﻥ‬
‫‪Label1.BackColor = Color.Blue‬‬
‫‪ .٥‬ﺸﻜل ﺍﻟﺤﺩ ‪ :‬ﺘﺴﺘﺨﺩﻡ ﻟﺘﻐﻴﻴﺭ ﺸﻜل ﺤﺩﻭﺩ ﺍﻷﺩﺍﺓ‪ ،‬ﻓﻲ ﺍﻟﻌﺎﺩﺓ ﻨﺴﺘﺨﺩﻤﻬﺎ ﻟﻠﺘﻔﺭﻴﻕ ﺒﻴﻥ ﺃﺩﻭﺍﺕ ﺍﻟﻌﻨﻭﺍﻥ‬
‫ﺍﻟﻤﺨﺘﻠﻔﺔ‪ .‬ﻤﺜل ﻟﻭ ﻜﺎﻥ ﻋﻨﺩﻙ ﻋﻠﻰ ﺍﻟﻨﺎﻓﺫﺓ ﺃﺩﻭﺍﺕ ﻋﻨﻭﺍﻥ ﻟﻌﺭﺽ ﺍﻷﺴﻌﺎﺭ ﻭ ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ ﻟﻌﺭﺽ‬
‫ﺍﻟﻤﺠﻤﻭﻉ ﻓﺎﻷﺩﺍﺓ ﺍﻷﺨﻴﺭﺓ ﺘﺄﺨﺫ ﻏﻴﺭ ﺍﻷﺩﻭﺍﺕ ﺍﻷﻭﻟﻰ‪ .‬ﻭﻫﻲ ﻤﺘﻭﻓﺭﺓ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﻭﺍﻟﺘﻨﻔﻴﺫ‬
‫‪lblHello‬‬ ‫ﻤﺜﺎل ﻟﻠﺘﻐﻴﻴﺭ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ﻷﺩﺍﺓ ﺍﺴﻤﻬﺎ‬
‫‪lblHello.BorderStyle = BorderStyle.Fixed3D‬‬

‫ﻟﺘﻐﻴﻴﺭ ﺤﺩﻭﺩ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ﺃﻨﻅﺭ ﺸﻜل )‪ (٤-٥‬ﻋﻨﺩﻤﺎ‬ ‫‪Fixed3D‬‬ ‫‪BorderStyle‬‬
‫ﺠﻌﻠﻨﺎ ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﻴﺔ ‪ Fixed3D‬ﻜﻤﺎ ﺘﻼﺤﻅ ﺍﻟﺤﺩﻭﺩ‬
‫ﺍﺼﺒﺤﺕ ﺜﻼﺜﻴﺔ ﺃﺒﻌﺎﺩ‪.‬‬
‫‪ FixedSingle‬ﻹﻅﻬﺎﺭ ﺤﺩ ﺨﻁﻲ‪.‬‬
‫ﻹﻟﻐﺎﺀ ﺍﻟﺤﺩ‪.‬‬ ‫‪None‬‬
‫ﺷﻜﻞ ‪ ٤-٥‬ﻋﻨﺪﻣﺎ ﻏﲑﻧﺎ ﻗﻴﻤﺔ ﺍﳋﺎﺻﻴﺔ ‪ BorderStyle‬ﺇﱃ ‪Fixed3D‬‬
‫‪٦٨‬‬
‫‪ .٦‬ﺍﻟﺘﺤﻘﻕ ‪ :‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻟﻠﺘﺤﻘﻕ ﻤﻥ ﺃﻱ ﺃﻤﺭ ﻴﺭﻴﺩﻩ ﺍﻟﻤﺴﺘﺨﺩﻡ‪ .‬ﻭﻫﻲ ﻤﺘﻭﻓﺭﺓ ﺃﺜﻨﺎﺀ‬
‫ﺍﻟﺘﺼﻤﻴﻡ ﻭﺍﻟﺘﻨﻔﻴﺫ‪.‬‬
‫ﻋﻨﺩ ﺍﺨﺘﻴﺎﺭ ‪ True‬ﻴﺘﻡ ﺭﺒﻁ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ﻤﻊ ﺃﺩﺍﺓ‬ ‫‪True‬‬ ‫‪CauseValidate‬‬
‫ﺃﺨﺭﻯ ﻟﻠﺘﺤﻘﻕ ﻤﻥ ﺸﺭﻭﻁ ﻤﻌﻴﻨﺔ ﻭﻤﻥ ﺜﻡ ﺴﻭﻑ ﻴﻨﻔﺫ‬
‫ﺍﻟﺤﺩﺙ ‪ .Validate‬ﺴﻴﺄﺘﻲ ﻟﻬﺎ ﻤﺯﻴﺩ ﺘﻔﺼﻴل ﻻﺤﻘﺎ‪.‬‬
‫ﻟﻥ ﻴﺘﻡ ﺘﻨﻔﻴﺫ ﻤﺎﺴﺒﻕ‪.‬‬ ‫‪False‬‬
‫‪ .٧‬ﻗﺎﺌﻤﺔ ﺍﻟﺯﺭ ﺍﻷﻴﻤﻥ ‪ :‬ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺘﺭﺒﻁ ﻗﺎﺌﻤﺔ ﺍﻟﺯﺭ ﺍﻷﻴﻤﻥ ﺒﺄﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ‪.‬‬
‫ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺘﺭﺒﻁ ﺍﻟﻘﺎﺌﻤﺔ ﺒﺄﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ‪ .‬ﻓﻌﻨﺩﻤﺎ‬ ‫ﺍﺴﻡ ﺍﻟﻘﺎﺌﻤﺔ‬ ‫‪Contextmenu‬‬
‫ﺘﻀﻐﻁ ﺍﻟﺯﺭ ﺍﻷﻴﻤﻥ ﻭﺍﻟﻤﺅﺸﺭ ﻋﻨﺩ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ﺴﻭﻑ‬
‫ﺘﻅﻬﺭ ﻟﻙ ﻗﺎﺌﻤﺔ‪ ،‬ﻫﻲ ﻨﻔﺱ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﺘﻲ ﺭﺒﻁﺕ ﺃﺩﺍﺓ‬
‫ﺍﻟﻌﻨﻭﺍﻥ ﺒﻬﺎ‪.‬‬
‫‪ .٨‬ﺍﻟﻤﺅﺸﺭ ‪ :‬ﻟﺘﻐﻴﻴﺭ ﻨﻭﻉ ﺍﻟﻤﺅﺸﺭ ﻋﻨﺩ ﻤﺭﻭﺭﺓ ﻓﻭﻕ ﻫﺫﻩ ﺍﻷﺩﺍﺓ‪ .‬ﻓﻲ ﺍﻟﻌﺎﺩﺓ ﺘﺴﺘﺨﺩﻡ ﺤﺴﺏ ﻨﻭﻉ‬
‫ﺍﻟﻤﺅﺸﺭ ﻓﻤﺜﻼ ﻤﺅﺸﺭ ﺍﻟﺴﺎﻋﺔ ﺍﻟﺭﻤﻠﻴﺔ ﻴﺨﺒﺭ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺒﺄﻥ ﻫﻨﺎﻙ ﻋﻤﻠﻴﺔ ﻤﺎ ﺘﺤﺩﺙ ﺍﻵﻥ‪ .‬ﻭﻫﻲ ﻤﺘﻭﻓﺭﺓ‬
‫ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﻭﺍﻟﺘﻨﻔﻴﺫ‪.‬‬
‫ﺘﺘﻴﺢ ﻟﻙ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺘﻐﻴﻴﺭ ﻨﻭﻉ ﻤﺅﺸﺭ ﺍﻟﻔﺄﺭﺓ ﻋﻨﺩ‬ ‫ﻨﻭﻉ ﺍﻟﻤﺅﺸﺭ‬ ‫‪Curser‬‬
‫ﻤﺭﻭﺭﺓ ﻓﻭﻕ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ‪ .‬ﻫﻨﺎﻙ ﻗﺎﺌﻤﺔ ﻤﻥ ﺍﻟﻤﺅﺸﺭﺍﺕ‬
‫ﺤﺎﻭل ﺘﺠﺭﺒﺘﻬﺎ‪.‬‬
‫‪ .٩‬ﺍﻟﺤﻭﺽ ‪ :‬ﻫل ﺘﺫﻜﺭ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﺸﺠﺭﻴﺔ ﻷﺴﻤﺎﺀ ﺍﻟﻤﺠﻠﺩﺍﺕ ﻓﻲ ﻤﺴﺘﻜﺸﻑ ﺍﻟﻨﻭﺍﻓﺫ ‪Windows‬‬
‫‪ .Explorer‬ﺍﻨﻬﺎ ﺜﺎﺒﺘﻪ ﻭﻤﺎﻟﺌﺔ ﻟﻠﺠﻬﺔ ﺍﻟﻴﺴﺭﻯ‪ .‬ﺇﺫﺍ ﺃﺭﺩﺕ ﺘﺜﺒﻴﺕ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ﻓﻲ ﺃﻱ ﺠﻬﺔ ﻓﻴﻤﻜﻨﻙ‬
‫ﻤﻥ ﺨﻼل ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ‪ .‬ﻓﻘﻁ ﺍﺨﺘﺭ ﺍﻟﺠﻬﺔ ﺍﻨﻅﺭ ﺍﻟﺸﻜﻠﻴﻥ )‪ (٦-٥‬ﻭ )‪ .(٧-٥‬ﻭﻫﻲ ﻤﺘﻭﻓﺭﺓ ﺃﺜﻨﺎﺀ‬
‫‪٦٩‬‬

‫ﺇﺫﺍ ﺃﺭﺩﺕ ﺃﻥ ﺘﻤﻸ ﺍﻷﺩﺍﺓ ﺍﻟﺠﺎﻨﺏ ﺍﻷﻴﻤﻥ ‪ .‬ﻓﻘﻁ ﺍﺨﺘﺭ‬ ‫‪Right‬‬ ‫‪Dock‬‬
‫ﺍﻟﺠﻬﺔﺍﻨﻅﺭ ﺍﻟﺸﻜﻠﻴﻥ )‪ (٦-٥‬ﻭ )‪.(٧-٥‬‬
‫ﺇﺫﺍ ﺃﺭﺩﺕ ﺃﻥ ﺘﻤﻸ ﺍﻷﺩﺍﺓ ﺍﻟﺠﺎﻨﺏ ﺍﻷﻴﺴﺭ‪.‬‬ ‫‪Left‬‬
‫ﺇﺫﺍ ﺃﺭﺩﺕ ﺃﻥ ﺘﻤﻸ ﺍﻷﺩﺍﺓ ﺍﻟﺠﺎﻨﺏ ﺍﻟﻌﻠﻭﻱ‪.‬‬ ‫‪Top‬‬
‫ﺇﺫﺍ ﺃﺭﺩﺕ ﺃﻥ ﺘﻤﻸ ﺍﻷﺩﺍﺓ ﺍﻟﺠﺎﻨﺏ ﺍﻟﺴﻔﻠﻲ‪.‬‬ ‫‪Bottom‬‬
‫ﺇﺫﺍ ﺃﺭﺩﺕ ﺃﻥ ﺘﻤﻸ ﺍﻷﺩﺍﺓ ﺍﻟﻨﺎﻓﺫﺓ ﻜﻠﻬﺎ‪.‬‬ ‫‪Fill‬‬
‫ﺇﺫﺍ ﻟﻡ ﺘﺭﻏﺏ ﺒﺎﺴﺘﺨﺩﺍﻡ ﻫﺫﻩ ﺍﻟﺤﺎﺼﻴﺔ؟‬ ‫‪Non‬‬
‫ﺷﻜﻞ ‪ ٦-٥‬ﻻﺣﻆ ﻛﻴﻒ ﺍﺧﺘﺮﻧﺎ ﺍﳉﻬﺔ ﺍﻟﻴﻤﲎ ﰒ ﻻﺣﻆ ﺷﻜﻞ ‪٧-٥‬‬
‫ﺷﻜﻞ ‪ ٧-٥‬ﻻﺣﻆ ﻛﻴﻒ ﺍﺣﺘﻠﺖ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻮﺍﻥ ﺍﳉﻬﺔ ﺍﻟﻴﻤﲎ ﻣﻦ ﺍﻟﻨﻤﻮﺫﺝ‬
‫‪ .١٠‬ﺍﻟﺘﻤﻜﻴﻥ ‪ :‬ﺘﺴﺘﺨﺩﻡ ﻟﻤﻨﻊ ﻫﺫﻩ ﺍﻷﺩﺍﺓ ﻤﻥ ﺍﻹﺴﺘﺠﺎﺒﺔ ﻟﻸﺤﺩﺍﺙ‪ .‬ﻤﺜﻼ ﻟﻭ ﺃﺭﺩﺕ ﻤﻨﻊ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻤﻥ‬
‫ﻨﻘﺭ ﺯﺭ ﺩﺨﻭل ﺤﺘﻰ ﻴﺩﺨل ﻜﻠﻤﺔ ﺍﻟﺴﺭ ﻭﺍﺴﻡ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺍﺠﻌل ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ‪ .False‬ﻭﻫﻲ ﻤﺘﻭﻓﺭﺓ‬
‫ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﻭﺍﻟﺘﻨﻔﻴﺫ‪.‬‬
‫‪٧٠‬‬

‫ﺘﻤﻜﻴﻥ ﻫﺫﻩ ﺍﻷﺩﺍﺓ ﻤﻤﺎ ﻴﺠﻌﻠﻬﺎ ﺘﺴﺘﺠﻴﺏ ﻟﻸﺤﺩﺍﺙ‪.‬‬ ‫‪True‬‬ ‫‪Enabled‬‬
‫ﻋﺩﻡ ﺘﻤﻜﻴﻥ ﻫﺫﻩ ﺍﻷﺩﺍﺓ ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪ (٨-٥‬ﻋﻨﺩﻤﺎ‬ ‫‪False‬‬
‫ﺍﺨﺘﺭﻨﺎ‪. False‬‬
‫ﺷﻜﻞ ‪ ٨-٥‬ﻻﺣﻆ ﻛﻴﻒ ‪‬ﺖ ﻟﻮﻥ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻮﺍﻥ ﺑﻌﺪ ﺃﻥ ﺟﻌﻠﻨﺎ‬

‫ﺧﺎﺻﻴﺔ ‪Enabled =False‬‬
‫‪ .١١‬ﺍﻟﺨﻁ ‪ :‬ﻟﺘﻐﻴﻴﺭ ﺨﺼﺎﺌﺹ ﺍﻟﺨﻁ ﻋﻠﻰ ﻫﺫﻩ ﺍﻷﺩﺍﺓ ﻭﻴﻨﺩﺭﺝ ﺘﺤﺕ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻋﺩﺓ ﺨﺼﺎﺌﺹ‬
‫ﻓﺭﻋﻴﺔ ﻭﻴﻤﻜﻥ ﺘﻐﻴﻴﺭ ﺠﻤﻴﻊ ﻫﺫﻩ ﺍﻟﺨﺼﺎﺌﺹ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﺃﻭ ﺍﻟﺘﻨﻔﻴﺫ‪.‬‬
‫ﺍﻟﺸﺭﺡ‬ ‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﻴﺔ ﺍﻟﻔﺭﻋﻴﺔ‬ ‫ﺍﻟﺨﺎﺼﻴﺔ‬

‫ﻴﻤﻜﻨﻙ ﺘﺤﺩﻴﺩ ﺍﺴﻡ ﺍﻟﺨﻁ ﺍﻟﺫﻱ ﺘﺭﻴﺩﻩ‪.‬‬ ‫‪FontName‬‬ ‫‪Font‬‬
‫ﺇﺫﺍ ﺃﺭﺩﺕ ﺃﻥ ﻴﻜﻭﻥ ﺍﻟﺨﻁ ﺴﻤﻴﻙ‬ ‫‪True‬‬ ‫‪FontBold‬‬
‫ﺇﺫﺍ ﺃﺭﺩﺕ ﺍﻟﺨﻁ ﻏﻴﺭ ﺴﻤﻴﻙ‬ ‫‪False‬‬

‫ﻟﻠﺘﺤﻜﻡ ﺒﺤﺠﻡ ﺍﻟﺨﻁ‬ ‫ﺭﻗﻡ‬ ‫‪FontSize‬‬
‫ﺼﺤﻴﺢ‬
‫ﻭﻀﻊ ﺴﻁﺭ ﺘﺤﺕ ﺍﻟﺨﻁ‬ ‫‪True FontStrikThru‬‬
‫‪False‬‬
‫ﻋﺩﻡ ﻭﻀﻊ ﺴﻁﺭ ﺘﺤﺕ ﺍﻟﺨﻁ‬
‫ﺇﺫﺍ ﺃﺭﺩﺕ ﺍﻟﺨﻁ ﻤﺎﺌل‬ ‫‪True‬‬ ‫‪FontItalic‬‬
‫‪False‬‬
‫ﺇﺫﺍ ﺃﺭﺩﺕ ﺍﻟﺨﻁ ﻏﻴﺭ ﻤﺎﺌل‬
‫‪٧١‬‬
‫‪ .١٢‬ﻟﻭﻥ ﺍﻟﻜﺘﺎﺒﺔ ‪ :‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻟﺘﻐﻴﻴﺭ ﻟﻭﻥ ﺍﻟﻜﺘﺎﺒﺔ‪ .‬ﻭﻫﻲ ﻤﺘﻭﻓﺭﺓ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﻭﺍﻟﺘﻨﻔﻴﺫ‪.‬‬
‫ﻟﺘﻐﻴﻴﺭ ﻟﻭﻥ ﺍﻟﺨﻁ‬ ‫‪ForeColor‬‬
‫‪ .١٣‬ﺍﻹﻏﻼﻕ ‪ :‬ﺘﺴﺘﺨﺩﻡ ﻟﺘﺜﺒﻴﺕ ﻤﻜﺎﻥ ﻭﺤﺠﻡ ﺍﻷﺩﺍﺓ ﻓﻲ ﻭﻗﺕ ﺍﻟﺘﺼﻤﻴﻡ‪ .‬ﻤﺜﺎل ‪ :‬ﻋﻨﺩ ﺍﻨﺘﻬﺎﺌﻙ ﻤﻥ‬
‫ﺘﺼﻤﻴﻡ ﻨﺎﻓﺫﺓ ﻤﻌﻴﻨﺔ ﺘﺭﻏﺏ ﻓﻲ ﺍﺴﺘﺨﺩﺍﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺤﺘﻰ ﻻﺘﻐﻴﺭ ﺤﺠﻡ ﺃﻭ ﻤﻜﺎﻥ ﺃﺩﺍﺓ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ‪.‬‬
‫ﻟﻥ ﺘﺴﺘﻁﻴﻊ ﺘﻜﺒﻴﺭ ﻭﻻ ﺘﺼﻐﻴﺭ ﻭﻻ ﺘﺤﺭﻴﻙ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ‬ ‫‪True‬‬ ‫‪Locked‬‬
‫ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ‪.‬‬
‫ﺘﺴﺘﻁﻴﻊ ﺘﻜﺒﻴﺭ ﻭ ﺘﺼﻐﻴﺭ ﻭ ﺘﺤﺭﻴﻙ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ﺃﺜﻨﺎﺀ‬ ‫‪False‬‬
‫ﺍﻟﺘﺼﻤﻴﻡ‪.‬‬
‫‪ .١٤‬ﺍﻟﻴﻤﻴﻥ ﻭﺍﻟﺸﻤﺎل ‪:‬‬

‫ﻋﺭﺽ ﺍﻟﻨﻤﻭﺫﺝ ﻤﻥ ﺍﻟﻴﻤﻴﻥ ﺇﻟﻰ ﺍﻟﺸﻤﺎل‬ ‫‪Yes‬‬ ‫‪RightToLeft‬‬
‫ﻋﺭﺽ ﺍﻟﻨﻤﻭﺫﺝ ﻤﻥ ﺍﻟﺸﻤﺎل ﺇﻟﻰ ﺍﻟﻴﻤﻴﻥ‬ ‫‪No‬‬
‫‪ .١٥‬ﺍﻟﺤﺠﻡ ‪ :‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻟﻠﺘﺤﻜﻡ ﺒﺤﺠﻡ ﺍﻷﺩﺍﺓ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﻭﺍﻟﺘﻨﻔﻴﺫ ﻭﻟﻬﺎ ﻋﺩﺓ ﺨﺼﺎﺌﺹ‬
‫ﻓﺭﻋﻴﺔ‪.‬‬
‫ﺍﻟﺸﺭﺡ‬ ‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﻴﺔ ﺍﻟﻔﺭﻋﻴﺔ‬ ‫ﺍﻟﺨﺎﺼﻴﺔ‬
‫ﻴﺤﺩﺩ ﻁﻭل ﻫﺫﻩ ﺍﻷﺩﺍﺓ‬ ‫‪Heght‬‬ ‫‪Size‬‬
‫ﻴﺤﺩﺩ ﻋﺭﺽ ﻫﺫﻩ ﺍﻷﺩﺍﺓ‬ ‫‪Width‬‬
‫‪ .١٦‬ﺍﻹﻨﺘﻘﺎل ﺒﻴﻥ ﺍﻷﺩﻭﺍﺕ ‪ :‬ﺘﺤﺩﺩ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺘﺭﺘﻴﺏ ﺍﻹﻨﺘﻘﺎل ﺒﻴﻥ ﺃﺩﻭﺍﺕ ﺍﻟﻨﺎﻓﺫﺓ‪ .‬ﻴﺤﺩﺩ ‪vb.net‬‬
‫ﺘﺭﺘﻴﺏ ﺍﻹﻨﺘﻘﺎل ﺍﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﺤﺴﺏ ﺇﻀﺎﻓﺘﻙ ﻟﻬﺫﻩ ﺍﻷﺩﺍﺓ ﻋﻠﻰ ﺍﻟﻨﺎﻓﺫﺓ ﻭﻴﻤﻜﻨﻙ ﺘﻌﺩﻴل ﻫﺫﺍ ﺍﻟﺘﺭﺘﻴﺏ‬
‫ﻜﻤﺎ ﺘﺭﻴﺩ‪ .‬ﻤﺘﻭﻓﺭﺓ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﻭﺍﻟﺘﻨﻔﻴﺫ‪ .‬ﻤﻊ ﻤﻼﺤﻅﺔ ﺃﻥ ﺍﻟﺒﺩﺀ ﻓﻲ ﺍﻟﺘﺭﺘﻴﺏ ﻴﻜﻭﻥ ﻤﻥ ﺍﻟﺼﻔﺭ‪.‬‬
‫‪٧٢‬‬

‫ﺒﻌﺩ ﺘﺸﻐﻴل ﺍﻟﺒﺭﻨﺎﻤﺞ ﺇﺫﺍ ﻀﻐﻁﺕ ﺯﺭ ‪Tab‬‬ ‫ﻤﻥ ‪ ١‬ﺇﻟﻰ ﻤﺠﻤﻭﻉ‬ ‫‪TabIndex‬‬
‫ﺴﻭﻑ ﻴﻨﺘﻘل ﺍﻟﻤﺅﺸﺭ ﻤﻥ ﻜﺎﺌﻥ ﺇﻟﻰ ﻜﺎﺌﻥ ﺁﺨﺭ‪.‬‬ ‫ﺍﻷﺩﻭﺍﺕ ﺍﻟﺘﻲ ﻋﻠﻰ‬
‫ﻭﺴﻭﻑ ﻴﻜﻭﻥ ﺘﺭﺘﻴﺏ ﺍﻟﺘﻨﻘل ﺤﺴﺏ ﻫﺫﻩ‬ ‫ﺍﻟﻨﺎﻓﺫﺓ ﻨﺎﻗﺹ ﻭﺍﺤﺩ‬
‫ﺍﻟﺨﺎﺼﻴﺔ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﺍﻟﺒﺩﺀ ﻓﻲ ﺍﻟﺘﺭﺘﻴﺏ ﻴﻜﻭﻥ ﻤﻥ ﺍﻟﺼﻔﺭ‪ .‬ﻟﺫﻟﻙ ﺘﻼﺤﻅ ﺃﻥ ﺍﻟﻘﻴﻤﺔ ﺘﺘﺭﺍﻭﺡ ﻤﻥ ‪ ١‬ﺇﻟﻰ‬
‫ﻤﺠﻤﻭﻉ ﺍﻷﺩﻭﺍﺕ ﺍﻟﺘﻲ ﻋﻠﻰ ﺍﻟﻨﺎﻓﺫﺓ ﻨﺎﻗﺹ ﻭﺍﺤﺩ ‪ .‬ﻤﺜﻼ ﺘﻜﻭﻥ ﺃﻭل ﺃﺩﺍﺓ ﺘﺭﻴﺩ ﺯﻴﺎﺭﺘﻬﺎ ﺘﺭﺘﻴﺒﻬﺎ‬
‫ﺼﻔﺭ ﻭﺍﻟﺜﺎﻨﻴﺔ ﻭﺍﺤﺩ ﻭﻫﻠﻡ ﺠﺭﺍ‪.‬‬
‫‪ .١٧‬ﺍﻟﻨﺹ ‪ :‬ﺘﻤﺜل ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺍﻟﻨﺹ ﺍﻟﻤﻜﺘﻭﺏ ﺩﺍﺨل ﻫﺫﻩ ﺍﻷﺩﺍﺓ ‪ .‬ﺘﺴﺘﺨﺩﻡ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﻭﺍﻟﺘﻨﻔﻴﺫ‬
‫‪ ،‬ﻤﺜﻼ ﻟﻭ ﺃﺭﺩﻨﺎ ﺘﻐﻴﻴﺭ ﺍﻟﻨﺹ ﺍﻟﻤﻜﺘﻭﺏ ﻋﻠﻰ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ﻭﺍﻟﺘﻲ ﻟﻬﺎ ﺍﻻﺴﻡ ‪ Label1‬ﺃﺜﻨﺎﺀ ﺍﻟﺘﺸﻐﻴل‬
‫ﺇﻟﻰ ﻤﺭﺤﺒﺎ ﺒﻜﻡ ‪.‬‬
‫"ﻤﺭﺤﺒﺎ ﺒﻜﻡ" = ‪Label1.Text‬‬

‫ﺍﻟﻨﺹ ﺍﻟﺫﻱ ﺘﺭﻴﺩ ﻋﺭﻀﻪ ﻋﻠﻰ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ‪.‬‬ ‫‪Text‬‬
‫‪ .١٨‬ﻤﺤﺎﺫﺍﺓ ﺍﻟﻨﺹ ﺍﻷﻓﻘﻴﺔ ‪ :‬ﺘﺘﻴﺢ ﻟﻙ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺘﻨﺴﻴﻕ ﺍﻟﻨﺹ ﺩﺍﺨل ﺍﻷﺩﺍﺓ ﺇﻤﺎ ﺇﻟﻰ ﺍﻟﻴﻤﻴﻥ ﺃﻭ ﺇﻟﻰ‬
‫ﺍﻟﻴﺴﺎﺭ ﺃﻭ ﻓﻲ ﺍﻟﻭﺴﻁ‪ .‬ﻭﻫﻲ ﻤﺘﻭﻓﺭﺓ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﻭﺍﻟﺘﻨﻔﻴﺫ‪ .‬ﻟﺘﻨﺴﻴﻕ ﺍﻟﻨﺹ ﻟﻠﻭﺴﻁ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺸﻐﻴل‬
‫ﻷﺩﺍﺓ ﺍﺴﻤﻬﺎ ‪.Label1‬‬
‫‪Label1.Textalig = Label1.HorizontalAlignment.Center‬‬

‫ﺘﻨﺴﻴﻕ ﺍﻟﻨﺹ ﺇﻟﻰ ﺍﻟﻴﻤﻴﻥ‪.‬‬ ‫‪Right‬‬ ‫‪TextAlign‬‬
‫ﺘﻨﺴﻴﻕ ﺍﻟﻨﺹ ﺇﻟﻰ ﺍﻟﻴﺴﺎﺭ‪.‬‬ ‫‪Left‬‬
‫ﺘﻨﺴﻴﻕ ﺍﻟﻨﺹ ﻓﻲ ﺍﻟﻭﺴﻁ‪.‬‬ ‫‪Center‬‬
‫‪٧٣‬‬
‫‪ .١٩‬ﺍﻟﺫﺍﻜﺭﻴﺔ ﺃﻭ ﺍﻟﺭﺍﺒﻁﺔ ‪ :‬ﺘﺴﺘﺨﺩﻡ ﻟﺘﺤﺩﻴﺩ ﻤﺎ ﺇﺫﺍ ﻜﺎﻨﺕ ﻫﺫﻩ ﺍﻷﺩﺍﺓ ﺴﻭﻑ ﺘﺴﺘﺠﻴﺏ ﻟﻌﻼﻤﺔ &‬
‫ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ ﺨﺎﺼﻴﺔ ﺍﻟﻨﺹ ﻟﻨﻔﺱ ﺍﻷﺩﺍﺓ‪ .‬ﺇﺫﺍ ﻜﺎﻨﺕ ﻗﻴﻤﺔ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ‪ True‬ﻓﺈﻨﻪ ﻴﺘﻡ ﺍﻟﻭﺼﻭل ﺇﻟﻰ‬
‫ﺍﻷﺩﺍﺓ ﺍﻷﺩﺍﺓ ﺍﻟﺘﻲ ﺘﻠﻲ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ﻓﻲ ﺘﺭﺘﻴﺏ ﺨﺎﺼﻴﺔ ‪ Tab‬ﻋﻥ ﻁﺭﻴﻕ ‪ + Alt‬ﺍﻟﺤﺭﻑ ﺍﻟﻤﺴﺒﻭﻕ‬
‫ﺒﻌﻼﻤﺔ & ﻓﻲ ﺨﺎﺼﻴﺔ ﺍﻟﻨﺹ ‪. Text‬‬

‫‪ True/False‬ﺇﺫﺍ ﺍﺨﺘﺭﻨﺎ ‪ True‬ﺴﻴﻜﻭﻥ ﺍﻟﺤﺭﻑ ﺍﻟﻤﺴﺒﻭﻕ ﺒﻌﻼﻤﺔ &‬ ‫‪UseMnoneic‬‬
‫ﻤﻊ ﺯﺭ ‪ Alt‬ﻫﻭ ﺍﻟﻤﻔﺘﺎﺡ ﻟﻠﻭﺼﻭل ﻟﻸﺩﺍﺓ ﺍﻟﺘﻲ ﺘﻠﻲ ﺃﺩﺍﺓ‬
‫ﺍﻟﻌﻨﻭﺍﻥ ﻓﻲ ﺍﻟﺘﺭﺘﻴﺏ‪.‬‬
‫‪٧٤‬‬
‫ﺃﺩﺍﺓ ﻤﺭﺒﻊ ﺍﻟﻨﺹ‬
‫ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﺘﺴﺘﺨﺩﻡ ﻹﺩﺨﺎل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﻋﺭﻀﻬﺎ ﻜﻤﺎ ﺘﺴﺘﺨﺩﻡ ﻟﺘﺤﺭﻴﺭ ﺍﻟﻨﺼﻭﺹ ‪.‬‬
‫ﻋﻨﺩﻤﺎ ﻴﻜﻭﻥ ﻋﻨﺩﻙ ﻤﺭﺒﻊ ﻨﺹ ﻹﺩﺨﺎل ﺍﺴﻤﺎﺀ ﺍﻟﻁﻼﺏ ﺍﺴﺘﺨﺩﻡ ﻤﺭﺒﻊ ﻨﺹ ﻟﻜﺘﺎﺒﺔ‬ ‫ﻤﺜﺎل‬
‫ﺷﻜﻞ ‪ : ١-٦‬ﺃﺩﺍﺓ ﻣﺮﺑﻊ ﺍﻟﻨﺺ‬ ‫ﺃﺴﻤﺎﺀ ﺍﻟﻁﻼﺏ‪.‬‬
‫ﺍﻟﺸﻜل)‪(١-٦‬‬
‫ﺨﺼﺎﺌﺹ ﻤﺭﺒﻊ ﺍﻟﻨﺹ‬
‫ﻫﻨﺎﻙ ﺨﺼﺎﺌﺹ ﻟﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺍﻟﻜﻼﻡ ﻓﻴﻬﺎ ﻨﻔﺱ ﺍﻟﻜﻼﻡ ﻋﻥ ﺨﺼﺎﺌﺹ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ﻭﻫﻲ ‪:‬‬
‫‪، CauseValidate ، Borderstyle ، Backcolor ، Autosize ، Anchor‬‬
‫‪، Locked ، ForeColor ، Font ، Enabled ، Dock ، Curser ، Contextmenu‬‬
‫‪TextAlign ، Text ، TabIndex ، Size‬‬
‫ﻭﻫﻨﺎﻙ ﺒﻌﺽ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﻲ ﻻﺘﻭﺠﺩ ﻓﻲ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ﻭﻫﻲ ﻤﺎﺴﻨﺸﺭﺤﻪ ﺍﻵﻥ ﺒﺈﺴﻬﺎﺏ ‪:‬‬
‫‪ -١‬ﺤﺎﻟﺔ ﺍﻷﺤﺭﻑ ‪ :CharacterCasing‬ﺘﺘﻴﺢ ﻟﻙ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺍﻟﺘﺤﻜﻡ ﺒﺤﺎﻟﺔ ﺍﻷﺤﺭﻑ ﺍﻟﺘﻲ‬

‫ﺘﺩﺨل ﺇﻟﻰ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻓﻴﻤﻜﻨﻙ ﺘﺤﻭﻴل ﻜل ﺤﺭﻑ ﻴﺩﺨﻠﻪ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺇﻟﻰ ﺍﻟﺤﺎﻟﺔ ﺍﻟﺘﻲ ﺘﺭﻴﺩ‬
‫ﺃﻭﺘﻭﻤﺎﺘﻴﻜﻴﺎ ﻜﻤﺎ ﺘﻤﻜﻨﻙ ﻤﻥ ﺘﺤﻭﻴل ﺤﺎﻟﺔ ﺍﻷﺤﺭﻑ ﺍﻟﻤﺩﺨﻠﺔ ﻓﻲ ﻤﺭﺒﻊ ﻨﺹ ﺇﻟﻰ ﺍﻟﺤﺎﻟﺔ ﺍﻟﺘﻲ‬
‫ﺘﺭﻴﺩ‪ .‬ﻤﺜﻼ ﺃﻨﺕ ﺘﺭﻴﺩ ﺃﻥ ﺘﻜﻭﻥ ﺤﺎﻟﺔ ﺠﻤﻴﻊ ﺍﻷﺤﺭﻑ ﺍﻟﺘﻲ ﻴﺩﺨﻠﻬﺎ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻜﺒﻴﺭﺓ ‪Capital‬‬
‫ﻴﻤﻜﻨﻙ ﻫﺫﺍ ﺒﺠﻌل ﻗﻴﻤﺔ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ‪ Upper‬ﻭﺒﺎﻟﺘﺎﻟﻲ ﻜﻠﻤﺎ ﺃﺩﺨل ﺍﻟﻤﺴﺘﺨﺩﻡ ﺤﺭﻑ ﺘﺤﻭل‬
‫ﺇﻟﻰ ﺤﺭﻑ ﻜﺒﻴﺭ‪ .‬ﺍﻨﻅﺭ ﺸﻜل )‪ (٢-٦‬ﻓﻲ ﻫﺫﺍ ﺍﻟﺸﻜل ﺍﻟﺤﺭﻭﻑ ﺘﺘﺤﻭل ﺘﻠﻘﺎﺌﻴﺎ ﻤﻥ ﺼﻐﻴﺭﺓ‬
‫ﺇﻟﻰ ﻜﺒﻴﺭﺓ‪ ،‬ﻓﻠﻭ ﺃﺭﺩﻨﺎ ﺘﺤﻭﻴل ﺤﺭﻭﻑ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺍﻟﺫﻱ ﺍﺴﻤﻪ ‪ TxtUpper‬ﺇﻟﻰ ﺤﺭﻭﻑ‬
‫ﻜﺒﻴﺭﺓ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ﺴﻨﻜﺘﺏ ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫‪٧٦‬‬
‫‪TxtUpper.CharcterCasing = CharcterCasing.Upper‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻟﺤﺭﻭﻑ ﺍﻟﻠﻐﺔ ﺍﻹﻨﺠﻠﻴﺯﻴﺔ ﻓﻘﻁ ﻓﻌﻨﺩﻤﺎ ﻴﺩﺨل ﺍﻟﻤﺴﺘﺨﺩﻡ ‪ b‬ﺘﺘﺤﻭل ﺇﻟﻰ‬
‫‪ B‬ﺇﺫﺍ ﻜﺎﻨﺕ ﺤﺎﻟﺔ ﺍﻷﺤﺭﻑ ‪.Upper‬‬

‫ﺘﺤﻭﻴل ﺍﻟﺤﺭﻭﻑ ﺇﻟﻰ ﻜﺒﻴﺭﺓ‪.‬‬ ‫‪Upper‬‬ ‫‪CharcterCasing‬‬
‫ﺘﺤﻭﻴل ﺍﻟﺤﺭﻭﻑ ﺇﻟﻰ ﺼﻐﻴﺭﺓ‪.‬‬ ‫‪Lower‬‬
‫ﺍﺒﻘﺎﺀ ﺤﺎﻟﺔ ﺍﻟﺤﺭﻑ ﻜﻤﺎ ﺃﺩﺨﻠﻬﺎ ﺍﻟﻤﺴﺘﺨﺩﻡ‪.‬‬ ‫‪Normal‬‬
‫ﺷﻜﻞ ‪ ٢-٦‬ﻻﺣﻆ ﲢﻮﻳﻞ ﺍﳊﺮﻭﻑ ﺇﱃ ﻛﺒﲑﺓ ﺗﻠﻘﺎﺋﻴﺎ‬
‫‪ -٢‬ﺍﺨﻔﺎﺀ ﺍﻟﺘﻅﻠﻴل ‪ :‬ﻋﻨﺩﻤﺎ ﺘﻅﻠل ﻨﺼﺎ ﻤﻭﺠﻭﺩ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻭﺘﻨﺘﻘل ﻤﻥ ﻫﺫﺍ ﺍﻟﻤﺭﺒﻊ ﻭﺘﺭﻴﺩ ﺃﻥ‬
‫ﻴﺒﻘﻰ ﺍﻟﺘﻅﻠﻴل ﺤﺘﻰ ﺒﻌﺩ ﺍﻨﺘﻘﺎﻟﻙ ﻤﻥ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺍﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ‪.‬ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪(٣-٦‬‬

‫ﺇﺒﻘﺎﺀ ﺍﻟﻨﺹ ﻤﻅﻼﻻ ﺒﻌﺩ ﺍﻹﻨﺘﻘﺎل ﻤﻥ ﻤﺭﺒﻊ ﺍﻟﻨﺹ‬ ‫‪True‬‬ ‫‪HideSelection‬‬
‫ﺇﺨﻔﺎﺀ ﺍﻟﺘﻅﻠﻴل ﺒﻌﺩ ﺍﻹﻨﺘﻘﺎل ﻤﻥ ﻤﺭﺒﻊ ﺍﻟﻨﺹ‬ ‫‪False‬‬
‫ﺷﻜﻞ ‪ ٣-٦‬ﺣﺎﻭﻝ ﺃﻥ ﺗﻨﻘﺮ ﺧﺎﺭﺝ ﻣﺮﺑﻊ ﺍﻟﻨﺺ ﻭﻻﺣﻆ ﺑﻘﺎﺀ ﺍﻟﺘﻈﻠﻴﻞ‬
‫‪-٣‬‬
‫‪-٤‬‬
‫‪٧٧‬‬
‫‪ -٣‬ﺍﻷﺴﻁﺭ )‪ : (Lines‬ﻋﻨﺩﻤﺎ ﺘﺭﻴﺩ ﻜﺘﺎﺒﺔ ﻨﺹ ﻁﻭﻴل ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ‬

‫ﺍﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻟﻜﺘﺎﺒﺔ ﺍﻟﻨﺹ ﺍﻟﻁﻭﻴل‪.‬‬
‫‪ -٤‬ﺍﻟﻤﻭﻗﻊ ‪ :‬ﺘﻤﺜل ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻤﻭﻗﻊ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻓﻲ ﺍﻟﻜﺎﺌﻥ ﺍﻟﺤﺎﻭﻱ ﻟﻤﺭﺒﻊ ﺍﻟﻨﺹ )ﺍﻨﻅﺭ‬
‫ﺍﻟﻤﻼﺤﻅﺔ ﺍﻟﺘﺎﻟﻴﺔ ( ﻭﺍﻟﻤﻭﻗﻊ ﻤﺤﺩﺩ ﺒﺨﺎﻨﺘﻲ ‪ X‬ﻭ ‪ Y‬ﻟﻠﺯﺍﻭﻴﺔ ﺍﻟﻴﺴﺭﻯ ﺍﻟﻌﻠﻭﻴﺔ ﻟﻤﺭﺒﻊ ﺍﻟﻨﺹ‪.‬‬
‫ﺤﺎﻭل ﺘﻐﻴﻴﺭ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻭﻻﺤﻅ ﺘﻐﻴﺭ ﻗﻴﻡ ‪ X‬ﻭ ‪Y‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻤﻭﻗﻊ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻴﻜﻭﻥ ﺒﺎﻟﻨﺴﺒﺔ ﻟﻠﺤﺎﻭﻱ ﺍﻟﺫﻱ ﻴﺤﻭﻱ ﺍﻟﻤﺭﺒﻊ‪ ،‬ﻫﺫﺍ ﺍﻟﺤﺎﻭﻱ ﻗﺩ ﻴﻜﻭﻥ‬
‫ﻤﺭﺒﻊ ﺘﺠﻤﻴﻊ ﺃﻭ ﻨﺎﻓﺫﺓ ﺃﻭ ﻏﻴﺭﻩ‪.‬‬

‫ﻤﻭﻗﻊ ﺍﻟﻨﻘﻁﺔ ﺱ ﻟﻠﺯﺍﻭﻴﺔ ﺍﻟﻴﺴﺭﻯ ﺍﻟﻌﻠﻭﻴﺔ‪.‬‬ ‫‪X‬‬ ‫‪Location‬‬
‫ﻤﻭﻗﻊ ﺍﻟﻨﻘﻁﺔ ﺹ ﻟﻠﺯﺍﻭﻴﺔ ﺍﻟﻴﺴﺭﻯ ﺍﻟﻌﻠﻭﻴﺔ‪.‬‬ ‫‪Y‬‬
‫‪ -٥‬ﺨﺎﺼﻴﺔ ﺍﻟﺤﺩ ﺍﻷﻗﺼﻰ ‪ :‬ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺘﺤﺩﺩ ﻋﺩﺩ ﺍﻷﺤﺭﻑ ﺍﻟﺘﻲ ﻴﻤﻜﻥ ﺇﺩﺨﺎﻟﻬﺎ ﻓﻲ ﻤﺭﺒﻊ‬
‫ﺍﻟﻨﺹ‪ ،‬ﻭﻫﻲ ﻤﺘﻭﻓﺭﺓ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﻭﺍﻟﺘﻨﻔﻴﺫ‪.‬‬
‫ﻻﻴﻭﺠﺩ ﻗﻴﺩ ﻋﻠﻰ ﻋﺩﺩ ﺍﻷﺤﺭﻑ ﺍﻟﻤﺩﺨﻠﺔ ﺃﻭ ﺍﻟﻤﻌﺭﻭﻀﺔ‪.‬‬ ‫‪٠‬‬ ‫‪MaxLength‬‬
‫ﻫﻭ ﺍﻟﺤﺩ ﺍﻷﻋﻠﻰ ﻟﻌﺩﺩ ﺍﻟﺤﺭﻭﻑ ﺍﻟﻤﺩﺨﻠﺔ ﻟﻸﺩﺍﺓ‪.‬‬ ‫ﺭﻗﻡ ﺼﺤﻴﺢ‬
‫‪ -٦‬ﺨﺎﺼﻴﺔ ﺍﻷﺴﻁﺭ ﺍﻟﻤﺘﻌﺩﺩﺓ ‪ :‬ﻤﺎﺫﺍ ﻟﻭ ﺃﺭﺩﺕ ﺃﻥ ﺘﻜﺘﺏ ﺃﻭ ﺘﻌﺭﺽ ﺃﻜﺜﺭ ﻤﻥ ﺴﻁﺭ ﻋﻠﻰ ﺃﺩﺍﺓ ﺍﻟﻨﺹ‪.‬‬
‫ﺍﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ‪.‬‬

‫ﺍﻤﻜﺎﻨﻴﺔ ﺘﻌﺩﺩ ﺍﻷﺴﻁﺭ ﻓﻲ ﺃﺩﺍﺓ ﺍﻟﻨﺹ‪.‬‬ ‫‪True‬‬ ‫‪MultiLine‬‬
‫ﻻﻴﻭﺠﺩ ﺇﻻ ﺴﻁﺭ ﻭﺍﺤﺩ ﻟﻠﻜﺘﺎﺒﺔ‪.‬‬ ‫‪False‬‬
‫‪٧٨‬‬
‫‪ : PasswordChar-٧‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻹﻅﻬﺎﺭ ﺭﻤﺯ ﻤﻌﻴﻥ ﺒﺩﻻ ﻤﻥ ﺍﻟﻨﺹ ﺍﻟﻤﻜﺘﻭﺏ‪ .‬ﻤﺜﺎل ‪:‬‬
‫ﻟﻭ ﻜﺎﻥ ﻋﻨﺩﻙ ﺸﺎﺸﺔ ﺍﺩﺨﺎل ﺍﻟﻜﻠﻤﺔ ﺍﻟﺴﺭﻴﺔ ﻓﺈﻨﻙ ﻻﺘﺭﻴﺩ ﺃﻥ ﺘﻅﻬﺭ ﺍﻟﺤﺭﻭﻑ ﺇﻨﻤﺎ ﺘﺭﻴﺩ ﺃﻥ ﻴﻅﻬﺭ ﺒﺩﻻ‬
‫ﻤﻨﻬﺎ ﻨﺠﻤﺔ ﺃﻭ ﺃﻱ ﺭﻤﺯ ﺁﺨﺭ‪ .‬ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪(٤-٦‬‬
‫ﺘﻅﻬﺭ ﻟﻙ ﻨﺠﻤﺔ ﺒﺩل ﺍﻟﺤﺭﻑ‪.‬‬ ‫*‬ ‫‪PasswordChar‬‬
‫ﺘﻅﻬﺭ ﻟﻙ ﻋﻼﻤﺔ ﺍﺴﺘﻔﻬﺎﻡ ﺒﺩل ﺍﻟﺤﺭﻑ‪.‬‬ ‫؟‬
‫ﺷﻜﻞ ‪ 0 ٤-٦‬ﻻﺣﻆ ﻇﻬﻮﺭ ﺍﻟﻨﺠﻤﺔ ﻣﻊ ﺃﻧﲏ ﺃﺩﺧﻞ ﺣﺮﻭﻑ‬
‫‪ -٨‬ﺍﻟﻘﺭﺍﺀﺓ ﻓﻘﻁ ‪ :‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺇﺫﺍ ﺃﺭﺩﺕ ﻋﺭﺽ ﻨﺹ ﻤﻌﻴﻥ ﻟﻠﻤﺴﺘﺨﺩﻡ ﺒﺩﻭﻥ ﺃﻥ ﺘﻤﻜﻨﻪ ﻤﻥ‬
‫ﺘﻌﺩﻴﻠﻪ‪.‬‬

‫ﻟﻥ ﻴﺘﻤﻜﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻤﻥ ﺘﻌﺩﻴل ﺍﻟﻨﺹ ﺍﻟﻤﻌﺭﻭﺽ ﺃﻭ‬ ‫‪True‬‬ ‫‪ReadOnly‬‬
‫ﺍﻟﻜﺘﺎﺒﺔ ﻋﻠﻰ ﻤﺭﺒﻊ ﺍﻟﻨﺹ‪.‬‬
‫ﺴﻭﻑ ﻴﺘﻤﻜﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻤﻥ ﺘﺤﺭﻴﺭ ﺍﻟﻨﺹ ﻭﺍﻟﻜﺘﺎﺒﺔ‬ ‫‪False‬‬
‫ﻋﻠﻰ ﻤﺭﺒﻊ ﺍﻟﻨﺹ‪.‬‬
‫‪ -٩‬ﺍﻟﺘﻭﻗﻑ ‪ :‬ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺘﺴﻤﺢ ﺒﺯﻴﺎﺭﺓ ﺃﻭ ﻋﺩﻡ ﺯﻴﺎﺭﺓ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ‪.Tab‬‬

‫ﺯﻴﺎﺭﺓ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻋﻨﺩ ﻀﻐﻁ ‪. Tab‬‬ ‫‪True‬‬ ‫‪TabStop‬‬
‫ﻋﺩﻡ ﺯﻴﺎﺭﺓ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻋﻨﺩ ﻀﻐﻁ ‪. Tab‬‬ ‫‪False‬‬
‫‪٧٩‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﺇﺫﺍ ﻜﺎﻨﺕ ﻗﻴﻤﺔ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ‪ True‬ﻓﺴﻭﻑ ﺘﺘﻡ ﺯﻴﺎﺭﺓ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺤﺴﺏ ﺍﻟﺘﺭﺘﻴﺏ‬
‫ﻟﺨﺎﺼﻴﺔ ﺍﻹﻨﺘﻘﺎل ﺒﻴﻥ ﺍﻷﺩﻭﺍﺕ) ‪.(TabIndex‬‬
‫‪ -١٠‬ﺍﻟﻅﻬﻭﺭ ‪ :‬ﺇﺫﺍ ﺃﺭﺩﺕ ﺍﺨﻔﺎﺀ ﺃﺩﺍﺓ ﻤﺎ ﺍﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ‪ .‬ﻭﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ‬
‫ﺘﻌﻤل ﻋﻨﺩ ﺍﻟﺘﺼﻤﻴﻡ ﻭﺍﻟﺘﻨﻔﻴﺫ‪ .‬ﻹﺨﻔﺎﺀ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ‪ txtName‬ﻋﻨﺩ ﺍﻟﺘﻨﻔﻴﺫ ﺍﻜﺘﺏ ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫‪TxtName.visible = False‬‬

‫ﺍﻅﻬﺎﺭ ﺍﻷﺩﺍﺓ‪.‬‬ ‫‪True‬‬ ‫‪Visible‬‬
‫ﺍﺨﻔﺎﺀ ﺍﻷﺩﺍﺓ‪.‬‬ ‫‪False‬‬
‫‪ -١١‬ﺍﻹﻟﺘﻔﺎﻑ ﺍﻟﺘﻠﻘﺎﺌﻲ ‪ :‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻤﻊ ﺨﺎﺼﻴﺔ ‪ MultiLine‬ﻹﻟﺘﻔﺎﻑ ﺍﻟﻨﺹ ﺍﻟﺘﻠﻘﺎﺌﻲ‬

‫ﺒﻤﻌﻨﻰ ﺃﻥ ﻴﺒﺩﺃ ﺍﻟﻨﺹ ﺴﻁﺭﺍ ﺠﺩﻴﺩﺍ ﺘﻠﻘﺎﺌﻴﺎ ﺇﺫﺍ ﻭﺼل ﺇﻟﻰ ﻨﻬﺎﻴﺔ ﺍﻟﺴﻁﺭ ﺍﻟﺤﺎﻟﻲ ‪ .‬ﻭﻫﻲ ﻤﺘﻭﻓﺭﺓ ﺃﺜﻨﺎﺀ‬
‫ﺍﻟﺘﻔﺎﻑ ﺘﻠﻘﺎﺌﻲ‪.‬‬ ‫‪True‬‬ ‫‪WordWrap‬‬
‫ﻟﻥ ﻴﺤﺼل ﺍﻟﺘﻔﺎﻑ ﺘﻠﻘﺎﺌﻲ ﻭﺴﻭﻑ ﺘﺴﺘﻤﺭ ﺍﻟﻜﺘﺎﺒﺔ ﻋﻠﻰ‬ ‫‪False‬‬
‫ﻨﻔﺱ ﺍﻟﺴﻁﺭ‪.‬‬
‫‪٨٠‬‬
‫ﺘﻁﺒﻴﻘﺎﺕ ﻋﻤﻠﻴﺔ ﻋﻠﻰ ﻤﺭﺒﻊ ﺍﻟﻨﺹ‬

‫ﺴﻭﻑ ﻨﻭﺭﺩ ﺘﻁﺒﻴﻕ ﻋﻠﻰ ﺃﻏﻠﺏ ﺨﺼﺎﺌﺹ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻭ ﺸﺭﺡ ﻟﻬﺎ ﻤﻥ ﺨﻼل ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫'ﻋﺮض ﻧﺺ ﻣﺮﺣﺒﺎ ﺑﻜﻢ ﻋﻠﻰ ﻣﺮﺑﻊ اﻟﻨﺺ‬
‫"ﺑﻜﻢ ﻣﺮﺣﺒﺎ" = ‪TextBox1.Text‬‬
‫ﺳﻮف ﳝﻜﻦ اﳌﺴﺘﻔﻴﺪ ﻣﻦ ﺿﻐﻂ زر اﻟﺮﺟﻮع ﳑﺎ ﻳﺆدي إﱃ ﻓﺘﺢ ﺳﻄﺮ ﺟﺪﻳﺪ‬ ‫'‬
‫‪TextBox1.AcceptsReturn = True‬‬
‫ﺳﻮف ﳝﻜﻦ ﻣﻦ ﻗﺒﻮل اﻻﻧﺘﻘﺎل إﱃ ﻣﺮﺑﻊ اﻟﻨﺺ ﺑﻌﺪ ﺿﻐﻂ زر ﺗﺎب‬ ‫'‬
‫‪TextBox1.AcceptsTab = True‬‬
‫ﺳﻮف ﻳﺘﻢ دﻣﺞ ﻋﺒﺎرة ﻣﺮﺣﺒﺎ ﺑﻜﻢ ﻣﺮة أﺧﺮى ﻣﻊ اﻟﻌﺒﺎرة اﻷوﱃ ﰲ ﺳﻄﺮ‬ ‫'‬
‫ﺟﺪﻳﺪ‬
‫)"أﺧﺮى ﻣﺮة ﺑﻜﻢ ﻣﺮﺣﺒﺎ" & ‪TextBox1.AppendText(vbCrLf‬‬
‫ﺗﻐﻴﲑ ﻟﻮن اﳋﻠﻔﻴﺔ إﱃ أزرق‬ ‫'‬
‫‪TextBox1.BackColor = Color.Blue‬‬
‫ﺗﻐﻴﲑ ﻟﻮن اﻟﻨﺺ إﱃ أﺳﻮد‬ ‫'‬
‫‪TextBox1.ForeColor = Color.Black‬‬
‫ﺟﻌﻞ ﺧﻠﻔﻴﺔ ﻣﺮﺑﻊ اﻟﻨﺺ اﻟﺼﻮرة‬ ‫'‬
‫= ‪TextBox1.BackgroundImage‬‬
‫)"‪Image.FromFile("C:\MyTextBoxBackground.gif‬‬
‫ﺗﻐﻴﲑ ﳕﻂ اﳊﺪود‬ ‫'‬
‫‪TextBox1.BorderStyle = BorderStyle.FixedSingle‬‬
‫ﻣﺴﺢ اﻟﻨﺺ اﳌﻮﺟﻮد ﰲ ﻣﺮﺑﻊ اﻟﻨﺺ‬ ‫'‬
‫)(‪TextBox1.Clear‬‬
‫ﺗﻐﻴﲑ ﻣﺆﺷﺮ اﻟﻔﺄرة إﱃ ﻳﺪ ﻋﻨﺪ ﻣﺮورﻩ ﻋﻠﻰ ﻣﺮﺑﻊ اﻟﻨﺺ‬ ‫'‬
‫‪TextBox1.Cursor = Cursors.Hand‬‬
‫ﺗﻐﻴﲑ اﳋﻂ ﳌﺮﺑﻊ اﻟﻨﺺ‬ ‫'‬
‫‪TextBox1.Font = New Drawing.Font("Comic Sans MS", 12,‬‬
‫)‪FontStyle.Bold, GraphicsUnit.Pixel‬‬
‫ﺗﻌﻴﲔ أﻗﺼﻰ ﻋﺪد ﻣﻦ اﳊﺮوف‬ ‫'‬
‫‪TextBox1.MaxLength = 3000‬‬
‫إرﺟﺎع اﻟﻨﺺ إﱃ اﻟﻘﻴﻤﺔ اﻻﻓﱰاﺿﻴﺔ‬ ‫'‬
‫)(‪TextBox1.ResetText‬‬
‫إﺿﺎﻓﺔ ﺷﺮﻳﻂ اﻧﺰﻻق إﱃ ﳝﲔ ﻣﺮﺑﻊ اﻟﻨﺺ‬ ‫'‬
‫‪TextBox1.ScrollBars = ScrollBars.Vertical‬‬
‫ﺳﻮف ﻳﺘﻢ ﺗﻈﻠﻴﻞ اﻟﻨﺺ ﻣﻦ اﻟﺒﺪاﻳﺔ ﺑﻄﻮل ‪ 12‬ﺣﺮﻓﺎ‬ ‫'‬
‫)‪TextBox1.Select(0, 11‬‬
‫ﺳﻮف ﻳﺘﻢ ﺗﻈﻠﻴﻞ آﻞ اﻟﻨﺺ ﰲ ﻣﺮﺑﻊ اﻟﻨﺺ‬ ‫'‬
‫)(‪TextBox1.SelectAll‬‬
‫ﺗﻌﺮﻳﻒ ﻣﺘﻐﲑ وﺗﻌﻴﲔ ﻗﻴﻤﺘﻪ ﺗﺴﺎوي اﻟﻨﺺ اﳌﻈﻠﻞ‬ ‫'‬
‫‪Dim SelectedText As String = TextBox1.SelectedText‬‬
‫ﺑﺪء اﻟﺘﻈﻠﻴﻞ ﻣﻦ أول ﺣﺮف‬ ‫'‬
‫‪TextBox1.SelectionStart = 0‬‬
‫ﻃﻮل اﻟﻨﺺ اﳌﻈﻠﻞ‬ ‫'‬
‫‪TextBox1.SelectionLength = 11‬‬
‫ﺗﻐﻴﲑ ﺣﺠﻢ ﻣﺮﺑﻊ اﻟﻨﺺ‬ ‫'‬
‫)‪TextBox1.Size = New Size(300, 400‬‬
‫ﻋﺮض اﻟﻨﺺ ﰲ ﻣﻨﺘﺼﻒ ﻣﺮﺑﻊ اﻟﻨﺺ‬ ‫'‬
‫‪TextBox1.TextAlign = HorizontalAlignment.Center‬‬
‫ﻋﺮﻓﻨﺎ ﻣﺘﻐﲑ ﻗﻴﻤﺘﻪ ﻃﻮل اﻟﻨﺺ اﳌﻮﺟﻮد ﰲ ﻣﺮﺑﻊ اﻟﻨﺺ‬ ‫'‬
‫‪Dim i As Integer = TextBox1.TextLength‬‬
‫اﻟﱰاﺟﻊ ﻋﻦ ﺁﺧﺮ ﲢﺮﻳﺮ ﳌﺮﺑﻊ اﻟﻨﺺ‬ ‫'‬
‫)(‪TextBox1.Undo‬‬
‫إﺧﻔﺎء ﻣﺮﺑﻊ اﻟﻨﺺ‬ ‫'‬
‫‪TextBox1.Visible = True‬‬
‫اﺧﺘﻴﺎر آﻞ اﻟﻨﺺ ﰒ ﻧﺴﺨﻪ‬ ‫'‬
‫)(‪TextBox1.SelectAll‬‬
‫‪٨١‬‬
kal_judaia@hotmail.com ‫ﺧﺎﻟﺪ ﺍﳉﺪﻳﻊ‬
TextBox1.Copy()
‫اﺧﺘﻴﺎر آﻞ اﻟﻨﺺ ﰒ ﻗﺼﻪ‬ '
TextBox1.SelectAll()
TextBox1.Cut()
٨٢
‫ﺯﺭ ﺍﻷﻤﺭ‬
‫ﺍﺴﺘﺨﺩﺍﻤﻪ ﻴﺴﺘﺨﺩﻡ ﺯﺭ ﺍﻷﻤﺭ ﻓﻲ ﺍﻟﻌﺎﺩﺓ ﻟﺘﻨﻔﻴﺫ ﻋﻤﻠﻴﺎﺕ ﻤﻌﻴﻨﺔ ﺒﻌﺩ ﺍﻟﻨﻘﺭ ﻋﻠﻴﻪ‪.‬‬
‫ﻋﻨﺩﻤﺎ ﻴﻜﻭﻥ ﻋﻨﺩﻙ ﻤﺭﺒﻊ ﻨﺹ ﻹﺩﺨﺎل ﺍﺴﻤﺎﺀ ﺍﻟﻁﻼﺏ ﺍﺴﺘﺨﺩﻡ ﺯﺭ ﺍﻷﻤﺭ – ﻤﺜﻼ‪-‬‬ ‫ﻤﺜﺎل‬
‫ﻟﺤﻔﻅ ﻫﺫﻩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻜﻤﺎ ﺴﻭﻑ ﺘﺘﻌﻠﻡ ﺇﻥ ﺸﺎﺀ ﺍﷲ‪.‬‬
‫ﻫﻨﺎﻙ ﺨﺼﺎﺌﺹ ﻟﺯﺭ ﺍﻷﻤﺭ ﺍﻟﻜﻼﻡ ﻓﻴﻬﺎ ﻨﻔﺱ ﺍﻟﻜﻼﻡ ﻋﻥ ﺨﺼﺎﺌﺹ ﺍﻷﺩﺍﻭﺍﺕ ﺍﻟﺴﺎﺒﻘﺔ ﻭﻫﻲ ‪:‬‬
‫‪، Dock ، Curser ، Contextmenu ، CauseValidate ، Backcolor ، Anchor‬‬
‫‪، Text ، TabStop، TabIndex ، Size ، Locked ، ForeColor ، Font ، Enabled‬‬
‫‪Visible ، TextAlign‬‬
‫ﻭﻫﻨﺎﻙ ﺒﻌﺽ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﻲ ﻻﺘﻭﺠﺩ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻭﻻ ﻓﻲ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ﻭﻫﻲ ﻤﺎﺴﻨﺸﺭﺤﻪ ﺍﻵﻥ‬
‫ﺒﺈﺴﻬﺎﺏ ‪:‬‬
‫‪ -١‬ﺍﻟﺨﻠﻔﻴﺔ ‪ :‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻟﻌﺭﺽ ﺼﻭﺭﺓ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪(١-٧‬‬
‫ﻜﻤﺎ ﺫﻜﺭﻨﺎ ﻤﺴﺒﻘﺎ ﻟﻥ ﻨﺘﻁﺭﻕ ﻟﺠﻤﻴﻊ ﺍﻟﺨﺼﺎﺌﺹ ﻷﻥ ﺫﻟﻙ ﺴﻴﻁﻭل ﺠﺩﺍ ﻭﺴﻴﻀﻴﻊ ﺍﻟﻔﺎﺌﺩﺓ ﻤﻥ ﻫﺫﺍ‬
‫ﺍﻟﻜﺘﺎﺏ ﺇﻨﻤﺎ ﺴﻭﻑ ﻨﺘﻜﻠﻡ ﻋﻥ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﻲ ﺘﺴﺎﻋﺩ ﻓﻲ ﺘﺤﻘﻴﻕ ﻫﺩﻑ ﻫﺫﺍ ﺍﻟﻜﺘﺎﺏ‪.‬‬
‫ﺷﻜﻞ ‪ ١-٧‬ﻻﺣﻆ ﺍﻟﺼﻮﺭﺓ ﻋﻠﻰ ﺯﺭ ﺍﻷﻣﺮ‬
‫‪٨٤‬‬
‫‪ -٢‬ﻨﺘﻴﺠﺔ ﻨﺎﻓﺫﺓ ﺍﻟﺤﻭﺍﺭ‪ : DialogResult‬ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺘﺤﺘﻔﻅ ﺒﻘﻴﻤﺔ ﻨﺘﻴﺠﺔ ﻨﺎﻓﺫﺓ ﺍﻟﺤﻭﺍﺭ‪،‬‬
‫ﻟﻨﻀﺭﺏ ﻟﻙ ﻤﺜﺎﻻ ﺤﺘﻰ ﺘﺘﻀﺢ ﺃﻜﺜﺭ‪ .‬ﻟﻨﻔﺘﺭﺽ ﺃﻥ ﺃﻤﺎﻤﻙ ﺸﺎﺸﺔ ﺤﻭﺍﺭ ﻓﻴﻬﺎ ﺯﺭﻱ ﺃﻤﺭ )ﻨﻌﻡ‬
‫‪ /‬ﻻ( ﻭﻗﻴﻤﺔ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻟﻬﻤﺎ ‪ Ok‬ﻟﻸﻭل ﻭ ‪ Cancel‬ﻟﻠﺜﺎﻨﻲ‪ .‬ﻓﺈﻨﻙ ﻟﻭ ﻨﻘﺭﺕ ﻋﻠﻰ ﺃﻱ‬
‫ﻤﻨﻬﻤﺎ ﻓﺴﻭﻑ ﺘﻐﻠﻕ ﻨﺎﻓﺫﺓ ﺍﻟﺤﻭﺍﺭ ﺒﺩﻭﻥ ﺍﻟﺤﺎﺠﺔ ﻟﻜﺘﺎﺒﺔ ﺃﻱ ﺃﻤﺭ ﻹﻏﻼﻗﻬﺎ ﻭﻜﺫﻟﻙ ﺴﻭﻑ‬
‫ﺘﺴﺘﻁﻴﻊ ﻤﻌﺭﻓﺔ ﺃﻱ ﺯﺭ ﺍﺨﺘﺎﺭﻩ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻷﻥ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺴﻭﻑ ﺘﺤﺘﻔﻅ ﻟﻙ ﺒﺎﺨﺘﻴﺎﺭﻩ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻴﺠﺏ ﺃﻥ ﺘﻜﻭﻥ ﻨﺎﻓﺫﺓ ﺍﻟﺤﻭﺍﺭ ﻗﺩ ﻓﺘﺤﺕ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻷﻤﺭ ‪ ShowDialog‬ﻟﻜﻲ ﺘﺼﺒﺢ‬
‫ﻨﺎﻓﺫﺓ ﺤﻭﺍﺭ‪ .‬ﺴﻭﻑ ﻨﻁﺒﻕ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺘﻔﺼﻴﻠﻴﺎ ﻓﻲ ﺍﻟﻔﺼل ﺍﻟﻘﺎﺩﻡ ﻓﻼ ﺘﻘﻠﻕ ﺇﺫﺍ ﻟﻡ ﺘﺴﺘﻭﻋﺒﻬﺎ‪.‬‬

‫ﺇﺫﺍ ﻟﻡ ﺘﺭﻏﺏ ﻓﻲ ﺍﺴﺘﺨﺩﺍﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ‪.‬‬ ‫‪None‬‬ ‫‪DialogResult‬‬
‫ﻗﻴﻤﺔ ﻟﻬﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ‪.‬‬ ‫‪Ok‬‬
‫ﻗﻴﻤﺔ ﻟﻬﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ‪.‬‬ ‫‪Cancel‬‬
‫‪ -٣‬ﺍﻟﻨﻤﻁ ‪ :FlatStyle‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻟﺘﻐﻴﻴﺭ ﺸﻜل ﺯﺭ ﺍﻷﻤﺭ ﻋﻨﺩﻤﺎ ﺘﻤﺭﺭ ﺍﻟﻔﺄﺭﺓ‬
‫ﻋﻠﻴﻪ ﺃﻭ ﺘﻀﻐﻁ ﻋﻠﻴﻪ ﺒﺎﻟﻔﺄﺭﺓ ﺍﻨﻅﺭ ﺍﻟﺸﻜل ‪ 1.12‬ﻫﻨﺎﻙ ﺜﻼﺜﺔ ﻗﻴﻡ ﻟﻬﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ‪ .‬ﻓﻲ ﺍﻟﺸﻜل‬
‫‪ 1.12‬ﻴﻤﻜﻨﻙ ﻤﻼﺤﻅﺔ ﺍﻟﺯﺭ ﻗﺒل ﺍﻟﻤﺭﻭﺭ ﻋﻠﻴﻪ ﺒﺎﻟﻔﺄﺭﺓ ﻭﺒﻌﺩ ﺍﻟﻤﺭﻭﺭ ﻋﻠﻴﻪ ﺒﺎﻟﻔﺄﺭﺓ ﻟﺘﻌﺭﻑ‬
‫ﺍﻟﻔﺭﻕ ﻤﻊ ﻤﻼﺤﻅﺔ ﺃﻥ ﺍﻟﺠﻬﺔ ﺍﻟﻴﺴﺭﻯ ﻗﺒل ﻤﺭﻭﺭ ﺍﻟﻔﺄﺭﺓ ﻭﺍﻟﺠﻬﺔ ﺍﻟﻴﻤﻨﻰ ﺒﻌﺩ ﻤﺭﻭﺭﻫﺎ‪ .‬ﻫﺫﻩ‬
‫ﺍﻟﺨﺎﺼﻴﺔ ﻤﺘﻭﻓﺭﺓ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﻭﺍﻟﺘﻨﻔﻴﺫ‪.‬‬
‫ﻫﻭ ﺍﻟﺸﻜل ﺍﻟﺜﺎﺍﻟﺙ ﻓﻲ ﺸﻜل )‪.(٢-٧‬‬ ‫‪Flat‬‬ ‫‪FlatStyle‬‬
‫ﻫﻭ ﺍﻟﺸﻜل ﺍﻟﺜﺎﻨﻲ ﻓﻲ ﺸﻜل)‪.(٢-٧‬‬ ‫‪PopUP‬‬
‫ﺍﻟﺸﻜل ﺍﻷﻭل ﻓﻲ ﺸﻜل)‪.(٢-٧‬‬ ‫‪Standard‬‬
‫ﺷﻜﻞ ‪ ٢-٧‬ﻻﺣﻆ ﺍﻟﻔﺮﻕ ﻋﻨﺪ ﲤﺮﻳﺮ ﺍﻟﻔﺄﺭﺓ ﰲ ﻫﺬﻩ ﺍﳋﺎﺻﻴﺔ‬
‫‪٨٥‬‬
‫ﻤﺭﺒﻊ ﺍﻹﺨﺘﻴﺎﺭ‬
‫ﺍﺴﺘﺨﺩﺍﻤﻪ ﻴﺴﺘﺨﺩﻡ ﻤﺭﺒﻊ ﺍﻹﺨﺘﻴﺎﺭ ﻟﺘﺤﺩﻴﺩ ﺃﻭ ﻋﺭﺽ ﺃﺤﺩ ﺍﻹﺨﺘﻴﺎﺭﺍﺕ ﻤﺜل )ﻨﻌﻡ‪/‬ﻻ( )ﺼﺢ‪/‬ﺨﻁﺄ(‬
‫ﻓﻴﻅﻬﺭ ﻓﻲ ﺍﻷﺩﺍﺓ ﻋﻼﻤﺔ ‪ 9‬ﻋﻨﺩ ﺍﻹﺨﺘﻴﺎﺭ ﻭ ﺘﺨﺘﻔﻲ ﻫﺫﻩ ﺍﻟﻌﻼﻤﺔ ﻋﻨﺩ ﻋﺩﻡ ﺍﻹﺨﺘﻴﺎﺭ‬
‫ﻭﻗﺩ ﻴﻜﻭﻥ ﻫﻨﺎﻙ ﻗﻴﻤﺔ ﺜﺎﻟﺜﺔ ﻭﻫﻲ ﻋﻼﻤﺔ ‪ 9‬ﻤﻅﻠﻠﺔ ﺘﻌﻨﻲ ﻋﺩﻡ ﺘﺤﺩﻴﺩ ﺍﻹﺨﺘﻴﺎﺭ‪.‬‬
‫ﻋﻨﺩﻤﺎ ﺘﺘﺼل ﺒﺎﻹﻨﺘﺭﻨﺕ ﺘﺄﺘﻴﻙ ﻨﺎﻓﺫﺓ ﻓﻴﻬﺎ ﻤﺭﺒﻊ ﺨﻴﺎﺭ ﻴﺴﺄﻟﻙ ﻫل ﺘﺭﻴﺩ ﺤﻔﻅ ﺍﻟﻜﻠﻤﺔ‬ ‫ﻤﺜﺎل‬
‫ﺍﻟﺴﺭﻴﺔ ﻋﻨﺩ ﺍﻟﺩﺨﻭل ﻓﻲ ﺍﻟﻤﺭﺓ ﺍﻟﻘﺎﺩﻤﺔ‪.‬‬
‫ﻫﻨﺎﻙ ﺨﺼﺎﺌﺹ ﻟﻤﺭﺒﻊ ﺍﻹﺨﺘﻴﺎﺭ ﺍﻟﻜﻼﻡ ﻓﻴﻬﺎ ﻨﻔﺱ ﺍﻟﻜﻼﻡ ﻋﻥ ﺨﺼﺎﺌﺹ ﺍﻷﺩﺍﻭﺍﺕ ﺍﻟﺴﺎﺒﻘﺔ ﻭﻫﻲ ‪:‬‬
‫‪، Contextmenu ، CauseValidate ،Background، Backcolor ،‬‬ ‫‪Anchor‬‬
‫‪، Size ، Locked ، ForeColor ، Font ، FlatStyle، Enabled ، Dock ، Curser‬‬
‫‪Visible ، TextAlign ، Text ، TabStop، TabIndex‬‬
‫ﻭﻫﻨﺎﻙ ﺒﻌﺽ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﻲ ﻻﺘﻭﺠﺩ ﻓﻲ ﺍﻷﺩﻭﺍﺕ ﺍﻟﺴﺎﺒﻘﺔ ﻭﻫﻲ ﻤﺎﺴﻨﺸﺭﺤﻬﺎ ﺍﻵﻥ ﺒﺈﺴﻬﺎﺏ ‪:‬‬
‫‪ -١‬ﺸﻜل ﺃﻭ ﻨﻤﻁ ﺍﻟﻅﻬﻭﺭ‪ :‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻟﻠﺘﺤﻜﻡ ﻓﻲ ﺸﻜل ﻤﺭﺒﻊ ﺍﻹﺨﺘﻴﺎﺭ ‪ .‬ﻫﻨﺎﻙ‬
‫ﺸﻜﻼﻥ ﺭﺌﻴﺴﺎﻥ ﺤﺴﺏ ﻗﻴﻤﺔ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ‪ .‬ﻭﻫﻲ ﻤﺘﻭﻓﺭﺓ ﻋﻨﺩ ﺍﻟﺘﺼﻤﻴﻡ ﻭﺍﻟﺘﻨﻔﻴﺫ‬
‫ﻫﻭ ﺍﻟﺸﻜل ﺍﻟﻌﺎﺩﻱ ﻜﻤﺎ ﻓﻲ ﺍﻟﺸﻜل )‪.(١-٨‬‬ ‫‪Normal‬‬ ‫‪Appearance‬‬
‫ﻴﺄﺨﺫ ﺸﻜل ﺯﺭ ﺍﻷﻤﺭ ﺍﻨﻅﺭ ﺸﻜل )‪.(١-٨‬‬ ‫‪Button‬‬
‫ﺳﻜﻞ ‪ ١-٨‬ﻻﺣﻆ ﺍﻟﻔﺮﻕ ﺑﲔ ﺍﻟﺸﻜﻠﲔ‬
‫‪٨٧‬‬
‫‪ -٢‬ﺍﻹﺨﺘﻴﺎﺭ ﺍﻟﺘﻠﻘﺎﺌﻲ ‪ :‬ﺘﺴﺘﺨﺩﻡ ﻟﺘﻐﻴﻴﺭ ﺤﺎﻟﺔ ﻤﺭﺒﻊ ﺍﻹﺨﺘﻴﺎﺭ ﺘﻠﻘﺎﺌﻴﺎ ﻋﻨﺩ ﺍﻟﻨﻘﺭ‪ .‬ﻭﻫﻲ ﻤﺘﻭﻓﺭﺓ ﻋﻨﺩ‬

‫ﺍﺨﺘﻴﺎﺭ ﺘﻠﻘﺎﺌﻲ ﻋﻨﺩ ﺍﻟﻨﻘﺭ ﺒﻤﻌﻥ ﺃﻨﻙ ﺴﻭﻑ ﺘﺭﻯ ﻋﻼﻤﺔ‬ ‫‪True‬‬ ‫‪AutoCheck‬‬
‫‪ 9‬ﻋﻨﺩ ﺍﻟﻨﻘﺭ‪.‬‬
‫ﻟﻥ ﺘﺘﻡ ﻋﻤﻠﻴﺔ ﺍﻹﺨﺘﻴﺎﺭ ﻤﻬﻤﺎ ﻨﻘﺭﺕ ﻋﻠﻰ ﻤﺭﺒﻊ‬ ‫‪False‬‬
‫ﺍﻹﺨﺘﻴﺎﺭ‪.‬‬
‫‪ -٣‬ﺘﻨﺴﻴﻕ ﺍﻹﺨﺘﻴﺎﺭ ‪ :‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻟﺘﻨﺴﻴﻕ ﺍﻟﻤﺭﺒﻊ ﺍﻟﺫﻱ ﻓﻲ ﻤﺭﺒﻊ ﺍﻹﺨﺘﻴﺎﺭ ‪ .‬ﺍﻨﻅﺭ‬
‫ﺍﻟﺸﻜل)‪ (٢-٨‬ﻋﻨﺩﻤﺎ ﺍﺨﺘﺭﻨﺎ ﺍﻟﻘﻴﻤﺔ ‪) TopCenter‬ﺃﻋﻠﻰ ﻤﺘﻭﺴﻁ( ‪ .‬ﻭﻫﻲ ﻤﺘﻭﻓﺭﺓ ﻋﻨﺩ‬

‫ﺍﻹﺘﺠﺎﻫﺎﺕ ﻋﻨﺩ ﺍﺨﺘﻴﺎﺭﻙ ﻟﺘﻨﺴﻴﻕ ﻤﺎ ﺴﻭﻑ ﻴﻅﻬﺭ ﺫﻟﻙ‬ ‫ﺠﻤﻴﻊ‬ ‫‪CheckAlign‬‬
‫ﻜﻤﺎ ﺘﺭﻯ ﻓﻲ ﺍﻟﺸﻜل ﺍﻟﺘﻨﺴﻴﻕ ﻓﻲ ﻤﺭﺒﻊ ﺍﻹﺨﺘﻴﺎﺭ ‪.‬‬
‫)‪(٣-٨‬‬
‫ﺷﻜﻞ ‪ ٣-٨‬ﻻﺣﻆ ﻋﻨﺪﻣﺎ ﺍﺧﺘﺮﻧﺎ ﺍﻟﺘﻨﺴﻴﻖ ﺍﻟﻮﺳﻂ ﺍﻟﻌﻠﻮﻱ ﻛﻴﻒ‬ ‫ﺷﻜﻞ ‪ ٢-٨‬ﻛﻤﺎ ﺗﻼﺣﻆ ﻛﻴﻒ ﺟﺎﺀ ﺍﳌﺮﺑﻊ ﰲ‬
‫ﺃﺛﺮ ﺫﻟﻚ ﰲ ﺷﻜﻞ ‪٢-٨‬‬ ‫ﺍﻟﻮﺳﻂ‬
‫‪٨٨‬‬
‫‪ -٤‬ﺍﻹﺨﺘﻴﺎﺭ ‪ :‬ﻨﺴﺘﻔﻴﺩ ﻤﻥ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻤﻌﺭﻓﺔ ﻤﺎ ﺇﺫﺍ ﻜﺎﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻗﺩ ﺍﺨﺘﺎﺭ )‪ (9‬ﺃﻭ ﻟﻡ‬
‫ﻴﺨﺘﺭ‪ .‬ﻭﻫﻲ ﻤﺘﻭﻓﺭﺓ ﻋﻨﺩ ﺍﻟﺘﺼﻤﻴﻡ ﻭﺍﻟﺘﻨﻔﻴﺫ‪.‬‬
‫ﻗﺎﻡ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺒﺎﻹﺨﺘﻴﺎﺭ‪.‬‬ ‫‪True‬‬ ‫‪Checked‬‬
‫ﻟﻡ ﻴﻘﻡ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺒﺎﻹﺨﺘﻴﺎﺭ‪.‬‬ ‫‪False‬‬
‫‪ -٥‬ﺤﺎﻟﺔ ﺍﻹﺨﺘﻴﺎﺭ ‪ :‬ﻨﺴﺘﻔﻴﺩ ﻤﻥ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻤﻌﺭﻓﺔ ﺤﺎﻟﺔ ﺍﻹﺨﺘﻴﺎﺭ‪.‬‬

‫ﻟﻡ ﻴﻘﻡ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺒﺎﻹﺨﺘﻴﺎﺭ‪.‬‬ ‫‪Unchecked‬‬ ‫‪CheckState‬‬
‫ﻗﺎﻡ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺒﺎﻹﺨﺘﻴﺎﺭ‪.‬‬ ‫‪Checked‬‬
‫‪ Indeterminate‬ﻏﻴﺭ ﻤﺤﺩﺩ ﻴﻌﻨﻲ ﻟﻡ ﻴﻭﺍﻓﻕ ﻭﻟﻡ ﻴﺭﻓﺽ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻻﺒﺩ ﺃﻥ ﺘﻜﻭﻥ ﺨﺎﺼﻴﺔ ‪ThreeState = True‬ﺤﺘىﺘﺘﻤﻜﻥ ﻤﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺨﺎﺼﻴﺔ‬

‫‪CheckState‬‬
‫‪ -٦‬ﺍﻟﺤﺎﻻﺕ ﺍﻟﺜﻼﺙ ‪ :‬ﺘﻤﻜﻨﻙ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻤﻥ ﻭﻀﻊ ﺤﺎﻟﺔ ﺜﺎﻟﺜﺔ ﻓﻲ ﻤﺭﺒﻊ ﺍﻹﺨﺘﻴﺎﺭ ﺘﻭﺠﺩ ﻓﻲ‬
‫ﺍﻟﻐﺎﻟﺏ ﻋﻨﺩﻤﺎ ﻻﻴﺴﺘﻁﻴﻊ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺍﻹﺨﺘﻴﺎﺭ ﻷﻱ ﻅﺭﻑ ﻤﺎ ) ﻤﺜل ﻋﺩﻡ ﺍﻟﻤﻌﺭﻓﺔ ﺃﻭ ﺍﻟﺘﺤﻔﻅ‬
‫ﻋﻥ ﺍﻹﺨﺘﻴﺎﺭ ﺃﻭ ﻏﻴﺭﻫﺎ( ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪.(٤-٨‬‬
‫ﺜﻼﺙ ﺤﺎﻻﺕ ﻟﻤﺭﺒﻊ ﺍﻹﺨﺘﻴﺎﺭ‪.‬‬ ‫‪True‬‬ ‫‪ThreeState‬‬
‫ﺤﺎﻟﺘﺎﻥ ﻓﻘﻁ ﺇﻤﺎ ‪ 9‬ﺃﻭ ﺒﺩﻭﻨﻬﺎ‪.‬‬ ‫‪False‬‬
‫ﺷﻜﻞ ‪ ٤-٨‬ﻻﺣﻆ ﺍﳊﺎﻻﺕ ﺍﻟﺜﻼﺙ‬
‫‪٨٩‬‬
‫ﺯﺭ ﺍﻹﺨﺘﻴﺎﺭ )‪(Radio Button‬‬
‫ﺍﺴﺘﺨﺩﺍﻤﻪ ﺘﺴﺘﺨﺩﻡ ﺃﺩﺍﺓ ﺯﺭ ﺍﻹﺨﺘﻴﺎﺭ ﻹﻋﻁﺎﺀ ﺍﻟﻔﺭﺼﺔ ﻟﻠﻤﺴﺘﺨﺩﻡ ﻹﺨﺘﻴﺎﺭ ﻭﺍﺤﺩ ﻤﻥ ﻋﺩﺓ‬
‫ﺍﺨﺘﻴﺎﺭﺍﺕ‪ .‬ﻴﻤﻜﻥ ﺘﺠﻤﻴﻊ ﺃﺩﺍﺓ ﺯﺭ ﺍﻹﺨﺘﻴﺎﺭ ﻓﻲ ﻤﺠﻤﻭﻋﺎﺕ ﻀﻤﻥ ﺍﻁﺎﺭ ﻭﺍﺤﺩ ﻭﻋﻨﺩ‬
‫ﺍﺨﺘﻴﺎﺭ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻷﺤﺩﻫﺎ ﻴﻠﻐﻲ ﺍﻟﻨﻅﺎﻡ ﺍﺨﺘﻴﺎﺭ ﺒﻘﻴﺔ ﺃﺯﺭﺍﺭ ﺍﻹﺨﺘﻴﺎﺭ ﻓﻲ ﻨﻔﺱ‬
‫ﺍﻟﻤﺠﻤﻭﻋﺔ‪.‬‬
‫ﺍﻟﺸﻜل)‪ (٥-٨‬ﻴﻭﻀﺢ ﻟﻙ ﺍﻟﻤﺜﺎل‪.‬‬ ‫ﻤﺜﺎل‬
‫ﺍﻟﻜﻼﻡ ﻓﻴﻬﺎ ﻨﻔﺱ ﺍﻟﻜﻼﻡ ﻋﻥ ﺨﺼﺎﺌﺹ ﻤﺭﺒﻊ ﺍﻹﺨﺘﻴﺎﺭ ﺒﻼ ﻓﺭﻕ ﻭﻫﻲ ‪:‬‬ ‫ﺨﺼﺎﺌﺹ ﺯﺭ ﺍﻹﺨﺘﻴﺎﺭ ‪:‬‬
‫‪،Background،‬‬ ‫‪Backcolor‬‬ ‫‪،‬‬ ‫‪AutoCheck‬‬ ‫‪،‬‬ ‫‪Appearance‬‬ ‫‪،Anchor‬‬
‫‪، Dock ، Curser ، Contextmenu ، Checked ، CheckAlign ، CauseValidate‬‬
‫‪، TabIndex ، Size‬‬ ‫‪، Locked ، ForeColor ، Font ، FlatStyle، Enabled‬‬
‫‪Visible ، TextAlign ، Text ،TabStop‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﺇﻥ ﻫﻨﺎﻙ ﺨﺼﺎﺌﺹ ﻓﻲ ﻤﺭﺒﻊ ﺍﻹﺨﺘﻴﺎﺭ ﻻﺘﻭﺠﺩ ﻓﻲ ﺯﺭ ﺍﻹﺨﺘﻴﺎﺭ ﻤﺜل ‪ThreeState‬‬
‫ﻗﺩ ﻻﻴﻅﻬﺭ ﻟﻙ ﺍﻟﻔﺭﻕ ﻭﺍﻀﺤﺎ ﺒﻴﻥ ﻤﺭﺒﻊ ﺍﻹﺨﺘﻴﺎﺭ ﻭ ﺯﺭ ﺍﻹﺨﺘﻴﺎﺭ ﻭﺍﻟﺘﻔﺭﻴﻕ ﺒﻴﻨﻬﻤﺎ ﻤﻬﻡ ﺠﺩﺍ‬
‫ﻷﻨﻪ ﻴﺅﺜﺭ ﻋﻠﻰ ﺍﺴﺘﺨﺩﺍﻤﻬﻤﺎ‪ .‬ﺍﻟﻔﺭﻕ ﺒﻴﻨﻬﻤﺎ ﻫﻭ ﺃﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻨﺩﻤﺎ ﻴﺨﺘﺎﺭ ﺯﺭ ﺃﻤﺭ ﻤﺎ ﻓﺈﻥ ﺍﻟﻨﻅﺎﻡ‬
‫ﻴﻠﻐﻲ ﺍﻹﺨﺘﻴﺎﺭ ﻋﻥ ﺠﻤﻴﻊ ﺍﻷﺯﺭﺍﺭ ﻓﻲ ﻨﻔﺱ ﺍﻟﻤﺠﻤﻭﻋﺔ ﻟﻜﻥ ﻤﺭﺒﻊ ﺍﻹﺨﺘﻴﺎﺭ ﻴﺴﻤﺢ ﻟﻙ ﺒﺎﻹﺨﺘﻴﺎﺭ‬
‫ﺍﻟﻤﺘﻌﺩﺩ ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪(٥-٨‬‬
‫ﺷﻜﻞ ‪ ٥-٨‬ﻻﺣﻆ ﺍﻟﻔﺮﻕ ﺑﲔ ﻣﺮﺑﻊ ﺍﻹﺧﺘﻴﺎﺭ ﻭ ﺯﺭ ﺍﻹﺧﺘﻴﺎﺭ‬
‫‪٩٠‬‬
‫ﺍﻟﺩﺭﺱ ﺍﻟﺜﺎﻨﻲ‬
‫ﺍﻟﺘﺩﺭﺏ ﺃﻜﺜﺭ ﻟﻠﺘﻌﺎﻤل ﻤﻊ ﻓﻴﺠﻭﺍل ﺒﻴﺴﻙ‬
‫ﺒﺭﻨﺎﻤﺞ ﺍﻷﻟﻭﺍﻥ‬
‫ﺴﻭﻑ ﻨﻘﻭﻡ ﻓﻲ ﺍﻟﺘﺩﺭﻴﺏ ﺍﻟﺘﺎﻟﻲ ﻟﻠﺘﺩﺭﺏ ﺃﻜﺜﺭ ﻋﻠﻰ ﻓﻴﺠﻭﺍل ﺒﻴﺴﻙ ﻭﺴﻭﻑ ﻴﻜﻭﻥ‬ ‫ﺍﻟﻬﺩﻑ‬
‫ﺍﻟﺘﺭﻜﻴﺯ ﻋﻠﻰ ﺍﻟﺘﻌﻭﺩ ﺃﻜﺜﺭ ﻓﻲ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻷﺩﻭﺍﺕ ﻭﺍﻟﺨﺼﺎﺌﺹ ﻭﺍﻷﺤﺩﺍﺙ‪.‬‬
‫ﻨﻤﻭﺫﺝ ﻭﺴﻭﻑ ﻨﻀﻴﻑ ﺇﻟﻴﻪ ﺜﻼﺙ ﺃﺯﺭﺍﺭ ﺍﺨﺘﻴﺎﺭ –‪ -RadioButton‬ﻭﺜﻼﺙ ﺃﺯﺭﺍﺭ‬ ‫ﺍﻷﺩﻭﺍﺕ‬
‫ﺃﻤﺭ ﻭﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ ﻭﻤﺭﺒﻊ ﺘﺠﻤﻴﻊ ﻟﺠﻤﻊ ﺍﻷﺯﺭﺍﺭ ﺍﻟﺜﻼﺜﺔ ﻓﻲ ﺇﻁﺎﺭ ﻭﺍﺤﺩ‪ .‬ﺍﻨﻅﺭ‬
‫ﺸﻜل)‪(٦-٨‬‬
‫ﺴﺘﻜﻭﻥ ﺍﻟﻌﻤﻠﻴﺔ ﻜﺎﻟﺘﺎﻟﻲ ‪ .‬ﺴﻭﻑ ﺘﻜﺘﺏ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺜﻡ ﺘﻨﻘﺭ ﺯﺭ ﻤﺭﺤﺒﺎ ﺜﻡ ﺴﻴﻨﺘﻘل‬ ‫ﺍﻟﻨﺎﺘﺞ‬
‫ﻤﺎﻜﺘﺒﺘﻪ ﻤﻥ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺇﻟﻰ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ‪ .‬ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺃﻱ ﻤﻥ ﺃﺯﺭﺍﺭ ﺍﻟﺭﺍﺩﻴﻭ‬
‫ﻴﺘﻐﻴﺭ ﻟﻭﻥ ﺍﻟﻨﺹ ﺍﻟﺫﻱ ﻋﻠﻰ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﺤﻭل ﺍﻟﺒﺭﻨﺎﻤﺞ‬
‫ﺘﻅﻬﺭ ﻟﻙ ﺭﺴﺎﻟﺔ " ﻫﺫﺍ ﻫﻭ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺜﺎﻨﻲ"‬
‫ﻤﻼﺤﻅﺔ ﻤﻬﻤﺔ ﺠﺩﺍ ‪ :‬ﻋﻨﺩ ﺍﻟﺒﺩﺀ ﻓﻲ ﺍﻟﺒﺭﻤﺠﺔ ﻻﺘﺤﺎﻭل ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺨﺎﺼﻴﺔ ﺍﻹﻓﺘﺭﺍﻀﻴﺔ ﻷﻱ ﻜﺎﺌﻥ‬
‫ﻷﻨﻬﺎ ﻻﺘﻌﻤل ﻓﻲ ‪ . vb.net‬ﻤﺜﺎل ﻓﻲ ﺍﻹﺼﺩﺍﺭ ﺍﻟﺴﺎﺒﻕ ﻤﻥ ﻓﻴﺠﻭﺍل ﺒﻴﺴﻙ ﺇﺫﺍ ﺃﺭﺩﺕ ﺃﻥ ﺘﻅﻬﺭ‬
‫ﺭﺴﺎﻟﺔ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻟﻨﻔﺘﺭﺽ ﺃﻥ ﺍﺴﻤﻪ ‪ txtName‬ﺒﺭﻤﺠﻴﺎ ﻴﻤﻜﻨﻙ ﻜﺘﺎﺒﺔ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ‬
‫" ﻤﺭﺤﺒﺎ" = ‪txtName.text‬‬
‫ﻜﺫﻟﻙ ﻴﻤﻜﻨﻙ ﻋﺩﻡ ﻜﺘﺎﺒﺔ ﺍﺴﻡ ﺍﻟﺨﺎﺼﻴﺔ ﻷﻨﻬﺎ ﺍﻟﺨﺎﺼﻴﺔ ﺍﻹﻓﺘﺭﺍﻀﻴﺔ ﻓﺘﺴﺘﻁﻴﻊ ﻜﺘﺎﺒﺔ ﺍﻟﻌﺒﺎﺭﺓ ﺒﺼﻭﺭﺓ‬
‫ﻤﻜﺎﻓﺌﺔ ﻜﻤﺎ ﻴﻠﻲ‬
‫ﻤﺭﺤﺒﺎ " = ‪TxtName‬‬
‫ﻻﺤﻅ ﺒﺩﻭﻥ ﺍﻟﺨﺎﺼﻴﺔ ‪ Text‬ﺃﻤﺎ ﻓﻲ ‪ vb.net‬ﻓﻼﻴﻤﻜﻥ ﺫﻟﻙ ﺒل ﻻﺒﺩ ﻤﻥ ﻜﺘﺎﺒﺔ ﺍﻟﻌﺒﺎﺭﺓ ﻜﺎﻤﻠﺔ ﻤﻊ‬
‫ﺍﻟﺨﺎﺼﻴﺔ ‪.‬‬
‫‪٩١‬‬

‫ﻀﻊ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ﺜﻡ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺜﻡ ﺜﻼﺜﺔ ﺃﺯﺭﺍﺭ ﺃﻤﺭ ﺜﻡ ﻀﻊ ﻤﺭﺒﻊ‬ ‫‪ -١‬ﻭﻀﻊ ﺍﻷﺩﺍﻭﺕ‬
‫ﺍﻟﺘﺠﻤﻴﻊ ﺜﻡ ﻀﻊ ﺜﻼﺜﺔ ﺃﺯﺭﺍﺭ ﺍﺨﺘﻴﺎﺭ ﻓﻭﻗﻪ ﻟﻜﻲ ﺘﻜﻭﻥ ﻤﺠﻤﻭﻋﺔ ﻭﺍﺤﺩﺓ‪.‬‬ ‫ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ‪.‬‬
‫ﺷﻜﻞ ‪ ٤-٨‬ﺍﻟﺘﺼﻤﻴﻢ ﺍﳌﺒﺪﺋﻲ ﻟﻨﻤﻮﺫﺝ ﺍﻷﻟﻮﺍﻥ‬
‫‪ -٢‬ﺘﻐﻴﻴﺭ ﺨﺼﺎﺌﺹ ﻏﻴﺭ ﺨﺼﺎﺌﺹ ﺍﻷﺩﻭﺍﺕ ﻟﺘﺼﺒﺢ ﻤﻁﺎﺒﻘﺔ ﻟﻠﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ﺍﻨﻅﺭ ﺍﻟﺸﻜل‬
‫)‪.(٦-٨‬‬ ‫ﺒﻌﺽ ﺍﻷﺩﻭﺍﺕ‬
‫)ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ(‪.‬‬
‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﻴﺔ‬ ‫ﺍﺴﻡ ﺍﻷﺩﺍﺓ‬
‫“ﺍﻟﺒﺭﻨﺎﻤﺞ‬ ‫‪Text‬‬ ‫‪Form1‬‬
‫ﺍﻷﻭل"‬
‫‪Right RightToLeft‬‬
‫‪rdbBlue‬‬ ‫‪Name RadioButton1‬‬
‫ﺃﺯﺭﻕ‬ ‫‪Text‬‬
‫‪rdbRed‬‬ ‫‪Name RadioButton2‬‬
‫ﺃﺤﻤﺭ‬ ‫‪Text‬‬
‫‪rdbGreen‬‬ ‫‪Name RadioButton3‬‬
‫ﺃﺨﻀﺭ‬ ‫‪Text‬‬
‫‪GrbColors‬‬ ‫‪Name‬‬ ‫‪GroupBox1‬‬
‫ﺃﻟﻭﺍﻥ‬ ‫‪Text‬‬
‫‪LblColor‬‬ ‫‪Name‬‬ ‫‪Label1‬‬
‫‪Text‬‬
‫‪txtColor‬‬ ‫‪Name‬‬ ‫‪Text1‬‬
‫‪٩٢‬‬
‫‪Text‬‬
‫‪cmdMove‬‬ ‫‪Name‬‬ ‫‪Button1‬‬
‫ﻨﻘل ﺍﻟﻨﺹ‬ ‫‪Text‬‬
‫‪cmdExit‬‬ ‫‪Name‬‬ ‫‪Button2‬‬
‫ﺨﺭﻭﺝ‬ ‫‪Text‬‬
‫‪CmeAbout‬‬ ‫‪Name‬‬ ‫‪Button3‬‬
‫ﺤﻭل ﺍﻟﺒﺭﻨﺎﻤﺞ‬ ‫‪Text‬‬
‫‪ .I‬ﺍﻨﻘﺭ ﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺯﺭ ﺍﻹﺨﺘﻴﺎﺭ ﺍﻷﺯﺭﻕ‪ .‬ﻭﺍﻜﺘﺏ ﺍﻟﺘﺎﻟﻲ‬ ‫‪ -٣‬ﺘﻐﻴﻴﺭ ﺨﺎﺼﻴﺔ‬

‫‪lblColor.ForeColor = color.Blue‬‬ ‫)‬ ‫ﻟﻭﻥ ﺍﻟﻜﺘﺎﺒﺔ‬
‫ﻓﻲ ﻫﺫﻩ ﺍﻟﻌﺒﺎﺭﺓ ﻨﻼﺤﻅ ﺃﻨﻨﺎ ﻨﻐﻴﺭ ﻗﻴﻤﺔ ﺨﺎﺼﻴﺔ ﻟﻭﻥ ﺍﻟﺨﻁ ﻷﺩﺍﺓ‬
‫‪ ( ForColor‬ﻷﺩﺍﺓ‬
‫ﺍﻟﻌﻨﻭﺍﻥ ﺇﻟﻰ ﺃﺯﺭﻕ‪ .‬ﻟﻭ ﺃﺭﺩﺕ ﺘﻐﻴﻴﺭ ﺍﻟﻠﻭﻥ ﺍﻟﺨﻠﻔﻲ ﺒﺩل ﻟﻭﻥ ﺍﻟﺨﻁ ﻀﻊ‬
‫ﺍﻟﻌﻨﻭﺍﻥ ﻋﻨﺩ ﺍﻟﻨﻘﺭ‬
‫‪ BackColor‬ﺒﺩﻻ ﻤﻥ ‪ .ForeColor‬ﺍﺭﺠﻊ ﺇﻟﻰ ﺸﺎﺸﺔ ﺍﻟﺘﺼﻤﻴﻡ‬
‫ﻋﻠﻰ ﺃﻱ ﻤﻥ ﺃﺯﺭﺍﺭ‬
‫‪ .II‬ﺍﻨﻘﺭ ﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺯﺭ ﺍﻹﺨﺘﻴﺎﺭ ﺍﻷﺤﻤﺭ ﻭﺍﻜﺘﺏ ﺍﻟﺘﺎﻟﻲ‬
‫ﺍﻷﺨﺘﻴﺎﺭ ﺜﻡ ﻻﺤﻅ ﺃﻥ‬
‫‪lblColor.ForeColor = color.red‬‬
‫ﺘﻐﻴﻴﺭ ﺍﻟﻠﻭﻥ ﻴﺘﻡ ﻋﻨﺩ‬
‫‪ .III‬ﺍﻨﻘﺭ ﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺯﺭ ﺍﻹﺨﺘﻴﺎﺭ ﺍﻷﺨﻀﺭ ﻭﺍﻜﺘﺏ ﺍﻟﺘﺎﻟﻲ‬
‫‪lblColor.ForeColor = color.Green‬‬ ‫‪) .‬ﺃﺜﻨﺎﺀ‬ ‫ﺍﻟﺤﺩﺙ‬
‫ﺍﻟﺘﻨﻔﻴﺫ(‬
‫ﺍﻨﻘﺭ ﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ "ﻨﻘل ﺍﻟﻨﺹ" ﻭﺍﻜﺘﺏ ﺍﻟﺘﺎﻟﻲ‬ ‫ﻨﻘل ﻤﺎﻴﻜﺘﺒﻪ‬ ‫‪-٤‬‬
‫ﺍﻟﻤﺴﺘﺨﺩﻡ ﻤﻥ ﺃﺩﺍﺓ‬
‫‪lblcolor.Text = txtColor.Text‬‬
‫ﻓﻲ ﻫﺫﻩ ﺍﻟﻌﺒﺎﺭﺓ ﺘﻼﺤﻅ ﺃﻨﻨﺎ ﻨﺄﺨﺫ ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﻴﺔ ‪txtColor.Text‬‬
‫ﺃﺩﺍﺓ‬ ‫ﺇﻟﻰ‬ ‫ﺍﻟﻨﺹ‬
‫ﻭﻨﻀﻌﻬﺎ ﻓﻲ ‪lblcolor.Text‬‬
‫ﺍﻟﻌﻨﻭﺍﻥ ﻭﺫﻟﻙ ﺒﻨﻘل‬
‫ﺍﻓﺘﺭﺽ ﺃﻥ‬
‫ﻗﻴﻤﺔ ﺨﺎﺼﻴﺔ ‪Text‬‬
‫ﺃﻫﻼ ﻭﺴﻬﻼ = ‪txtColor.Text‬‬
‫ﺍﻟﻨﺹ‬ ‫ﺃﺩﺍﺓ‬ ‫ﻓﻲ‬
‫ﺒﻌﺩ ﺘﻨﻔﻴﺫ ‪ lblcolor.Text = txtColor.Text‬ﺴﻭﻑ ﺘﺼﺒﺢ ﻗﻴﻤﺔ‬
‫ﻓﻲ‬ ‫ﻭﻭﻀﻌﻬﺎ‬
‫‪ lblcolor.Text‬ﺃﻫﻼ ﻭﺴﻬﻼ‪.‬‬
‫ﺨﺎﺼﻴﺔ ‪ Text‬ﻷﺩﺍﺓ‬
‫ﺍﻟﻌﻨﻭﺍﻥ ﻻﺤﻅ ﺃﻥ‬
‫‪٩٣‬‬
‫ﻋﻤﻠﻴﺔ ﺍﻟﻨﻘل ﺴﻭﻑ‬

‫ﺘﺘﻡ ﻋﻨﺩ ﺍﻟﻨﻘﺭ ﻋﻠﻰ‬
‫‪cmdMove‬‬ ‫ﺯﺭ‬
‫ﺃﻱ ﻋﻨﺩ ﺤﺩﺙ ﺍﻟﻨﻘﺭ‬
‫ﻟﻬﺫﻩ ﺍﻷﺩﺍﺓ‪.‬‬
‫ﺍﻨﻘﺭ ﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ ‪ cmdAbout‬ﻭﺃﻜﺘﺏ ﺍﻟﺘﺎﻟﻲ‬ ‫‪ -٥‬ﻋﺭﺽ ﺭﺴﺎﻟﺔ‬
‫‪",‬أﻟﻮان" ‪",‬اﻷﻟﻮان ﺑﺮﻧﺎﻣﺞ هﻮ هﺬا"(‪MessageBox.Show‬‬
‫)‪MessageBoxButtons.OK, MessageBoxIcon.Exclamation‬‬ ‫ﻋﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ‬
‫ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﺩﺍﻟﺔ‬
‫ﻫﺫﻩ ﺍﻟﻌﺒﺎﺭﺓ ﺴﻭﻑ ﺘﻅﻬﺭ ﻟﻨﺎ ﺭﺴﺎﻟﺔ ﻤﻜﺘﻭﺏ ﻋﻠﻴﻬﺎ ﻫﺫﺍ ﻫﻭ ﺒﺭﻨﺎﻤﺞ‬ ‫‪MessageBox.Show‬‬
‫ﺍﻷﻟﻭﺍﻥ‪.‬‬ ‫ﻤﻊ ﺸﺭﺡ ﻤﺒﺴﻁ ﻟﻬﺫﻩ‬

‫ﻴﻌﻨﻲ ﺼﻨﺩﻭﻕ ﺍﻟﺭﺴﺎﻟﺔ ‪.‬‬ ‫‪MessageBox.Show‬‬ ‫ﻜﻤﺎ ﺘﻼﺤﻅ ﺍﻷﻤﺭ ﻫﻭ‬ ‫ﺍﻟﺩﺍﻟﺔ‪ .‬ﻻﺤﻅ ﺃﻥ‬
‫ﻫﺫﻩ ﻫﻲ ﺩﺍﻟﺔ ﻭﻟﻬﺎ ﺜﻼﺜﺔ ﻋﻭﺍﻤل ﺘﺤﺘﺎﺝ ﺇﻟﻴﻬﺎ ‪.‬‬ ‫ﻋﺭﺽ ﺍﻟﺭﺴﺎﻟﺔ‬
‫‪MessageBox.Show‬‬ ‫)ﻨﻭﻉ ﺍﻟﺭﺴﺎﻟﺔ‪ ،‬ﻋﻨﻭﺍﻥ ﺍﻟﺭﺴﺎﻟﺔ ‪ ،‬ﺍﻟﺭﺴﺎﻟﺔ(‬ ‫ﺴﻭﻑ ﻴﺘﻡ ﻋﻨﺩ ﺍﻟﻨﻘﺭ‬
‫ﺍﻟﺭﺴﺎﻟﺔ ‪ :‬ﻭﺘﻜﺘﺏ ﻓﻴﻬﺎ ﺍﻟﺭﺴﺎﻟﺔ ﺍﻟﺘﻲ ﺘﺭﻴﺩ ﺍﻅﻬﺎﺭﻫﺎ‪.‬‬ ‫ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ‬
‫ﻨﻭﻉ ﺍﻟﺭﺴﺎﻟﺔ ‪ :‬ﻭﺴﻭﻑ ﺘﻅﻬﺭ ﻟﻙ ﻗﺎﺌﻤﺔ ﺃﻨﻭﺍﻉ ﻜﺜﻴﺭﺓ ﺘﺨﺘﺎﺭ ﻤﺎﻴﻨﺎﺴﺒﻙ‪.‬‬ ‫‪.cmdAbout‬‬
‫ﻤﺜﻼ ﻫﻨﺎﻙ ﺭﺴﺎﺌل ﺘﺤﺫﻴﺭﻴﻪ ﻭﺭﺴﺎﺌل ﺘﺄﻜﻴﺩﻴﻪ ﻭﺭﺴﺎﺌل ﻤﻌﻠﻭﻤﺎﺘﻴﻪ ‪.‬‬

‫ﻭﻨﺤﻥ ﻓﻲ ﻫﺫﺍ ﺍﻟﻤﺜﺎل ﺍﺨﺘﺭﻨﺎ ‪ Information‬ﻭﻫﻲ ﺍﻟﻤﻌﻠﻭﻤﺎﺘﻴﻪ‬
‫ﻭﺃﻨﺼﺤﻙ ﺒﺘﻐﻴﻴﺭ ﻨﻭﻉ ﺍﻟﺭﺴﺎﻟﺔ ﻋﺩﺓ ﻤﺭﺍﺕ ﻟﺘﻌﺭﻑ ﺍﻟﻔﺭﻕ ﺒﻴﻨﻬﺎ‪.‬‬
‫‪ -٦‬ﺍﻨﻬﺎﺀ ﺍﻟﺒﺭﻨﺎﻤﺞ‬
‫‪ -٦‬ﺍﻨﻘﺭ ﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ ﺨﺭﻭﺝ ﻭﺍﻜﺘﺏ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ‬
‫ﻋﻨﺩ ﺍﻟﻨﻘﺭ ﻋﻠﻰ ﺯﺭ‬
‫‪End‬‬
‫‪.cmdExit‬‬
‫ﻫﺫﻩ ﺍﻟﻌﺒﺎﺭﺓ ﺴﻭﻑ ﺘﻨﻬﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻜﺎﻤﻼ‪.‬‬
‫‪٩٤‬‬
‫ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺤﺴﺏ ﺍﻟﺨﻁﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ‬
‫‪ -١‬ﺃﻜﺘﺏ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺃﻫﻼ ﻭﺴﻬﻼ ﺒﻜﻡ‪.‬‬
‫‪ -٢‬ﺍﻨﻘﺭ ﻤﺭﻩ ﻭﺍﺤﺩﺓ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ ﻨﻘل ﺍﻟﻨﺹ ﺜﻡ ﻻﺤﻅ ﺍﻨﺘﻘﺎل ﺍﻟﻨﺹ ﺍﻟﻰ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ‪.‬‬
‫‪ -٣‬ﺍﻨﻘﺭ ﺯﺭ ﺍﻹﺨﺘﻴﺎﺭ ﺃﺯﺭﻕ ﻤﺭﺓ ﻭﺍﺤﺩﺓ ﺜﻡ ﻻﺤﻅ ﺘﻐﻴﺭ ﻟﻭﻥ ﺍﻟﻨﺹ ﻓﻲ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ‪.‬‬
‫‪ -٤‬ﺃﻨﻘﺭ ﺯﺭ ﺤﻭل ﺍﻟﺒﺭﻨﺎﻤﺞ ﻟﺘﻅﻬﺭ ﻟﻙ ﺍﻟﺭﺴﺎﻟﺔ ‪ :‬ﻫﺫﺍ ﻫﻭ ﺒﺭﻨﺎﻤﺞ ﺍﻷﻟﻭﺍﻥ‪.‬‬
‫‪ -٥‬ﻴﺠﺏ ﺃﻥ ﻴﻜﻭﻥ ﺍﻟﺸﻜل ﻤﻁﺎﺒﻘﺎ ﻟﻠﺸﻜل )‪.(٧-٨‬‬
‫‪ -٦‬ﺍﻨﻘﺭ ﺯﺭ ﺨﺭﻭﺝ ﻷﻨﻬﺎﺀ ﺍﻟﺒﺭﻨﺎﻤﺞ‪.‬‬
‫ﺷﻜﻞ ‪ ٧-٨‬ﺑﻌﺪ ﺍﲤﺎﻡ ﺍﳋﻄﻮﺍﺕ ﻣﻦ ‪ ١‬ﺇﱃ ‪٤‬‬
‫‪٩٥‬‬
‫ﺃﺩﺍﺓ ﺍﻟﻘﺎﺌﻤﺔ )‪(List Box‬‬
‫ﺍﺴﺘﺨﺩﺍﻤﻪ ﺘﺴﺘﺨﺩﻡ ﺃﺩﺍﺓ ﺍﻟﻘﺎﺌﻤﺔ ﻟﻌﺭﺽ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﻌﻨﺎﺼﺭ )ﺒﻴﺎﻨﺎﺕ( ﻟﻠﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﺸﻜل‬
‫ﻗﺎﺌﻤﺔ ﺒﺤﻴﺙ ﻴﺘﻤﻜﻥ ﻤﻥ ﺍﺨﺘﻴﺎﺭ ﻋﻨﺼﺭ ﺃﻭ ﺃﻜﺜﺭ ﺇﻥ ﻜﺎﻥ ﺫﻟﻙ ﻤﺴﻤﻭﺤﺎ ﺍﻨﻅﺭ ﺍﻟﺸﻜل‬
‫)‪(١-٩‬‬
‫ﺇﺫﺍ ﺃﺭﺩﺕ ﻋﺭﺽ ﻗﺎﺌﻤﺔ ﺃﺴﻤﺎﺀ ﺍﻟﻤﺩﻥ ﺃﻭ ﺍﻹﺩﺍﺭﺍﺕ ﺃﻭ ﻏﻴﺭﻫﺎ ﻤﻥ ﺍﻟﻘﻭﺍﺌﻡ‪.‬‬ ‫ﻤﺜﺎل‬
‫ﺷﻜﻞ ‪ ١-٩‬ﻻﺣﻆ ﺍﻟﺸﻜﻞ ﺍﻟﻌﺎﻡ ﻟﻠﻘﺎﺋﻤﺔ‬
‫ﺨﺼﺎﺌﺹ ﺯﺭ ﺍﻹﺨﺘﻴﺎﺭ ‪ :‬ﺍﻟﻜﻼﻡ ﻓﻴﻬﺎ ﻨﻔﺱ ﺍﻟﻜﻼﻡ ﻋﻥ ﺨﺼﺎﺌﺹ ﻤﺭﺒﻊ ﺍﻹﺨﺘﻴﺎﺭ ﺒﻼ ﻓﺭﻕ ﻭﻫﻲ ‪:‬‬
‫‪، Contextmenu ، CauseValidate ،‬‬ ‫‪BorderStyle،Backcolor ،Anchor‬‬
‫‪، Size ، Locked ، Location،ForeColor ، Font ، Enabled ، Dock ، Curser‬‬
‫‪Visible ، TabStop، TabIndex‬‬
‫ﻭﻫﻨﺎﻙ ﺒﻌﺽ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﻲ ﻻﺘﻭﺠﺩ ﻓﻲ ﺍﻷﺩﻭﺍﺕ ﺍﻟﺴﺎﺒﻘﺔ ﻭﻫﻲ ﻤﺎﺴﻨﺸﺭﺤﻪ ﺍﻵﻥ ﺒﺎﻟﺘﻔﺼﻴل ‪:‬‬
‫‪ -١‬ﻋﺭﺽ ﺍﻟﻌﻤﻭﺩ ‪ :‬ﻴﺴﺘﻁﻴﻊ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺘﺤﺩﻴﺩ ﻋﺭﺽ ﺍﻷﻋﻤﺩﺓ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﻤﻥ ﺨﻼل ﻫﺫﻩ‬
‫ﺍﻟﺨﺎﺼﻴﺔ ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻻﺒﺩ ﺃﻥ ﺘﻜﻭﻥ ﺨﺎﺼﻴﺔ ‪ MultiColumn = True‬ﺤﺘﻰ ﺘﺘﻤﻜﻥ ﻤﻥ ﺍﺴﺘﺨﺩﺍﻡ ﻫﺫﻩ‬
‫ﺍﻟﺨﺎﺼﻴﺔ‪.‬‬
‫‪٩٧‬‬

‫ﺍﻟﻨﻅﺎﻡ ﺴﻭﻑ ﻴﺤﺩﺩ ﻋﺭﺽ ﺍﻷﻋﻤﺩﺓ‪.‬‬ ‫ﺼﻔﺭ‬ ‫‪ColumnWidht‬‬
‫ﻋﺭﺽ ﺍﻟﻌﻤﻭﺩ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﻤﺘﻌﺩﺩﺓ ﺍﻷﻋﻤﺩﺓ‪.‬‬ ‫ﻋﺩﺩ ﺼﺤﻴﺢ‬
‫‪-٢‬ﻤﺼﺩﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ )‪ : (DataSource‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻟﺘﺤﺩﻴﺩ ﻤﺼﺩﺭ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺘﻲ‬

‫ﺴﻭﻑ ﺘﻌﺭﺽ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ‪.‬‬
‫ﻤﺜﺎل ﻟﻤﺼﺩﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ :‬ﺠﺩﻭل ﺃﺴﻤﺎﺀ ﺍﻹﺩﺍﺭﺍﺕ ﻤﻥ ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ‪.‬‬
‫‪-٣‬ﺍﻟﻤﻌﺭﻭﺽ )‪ :(DisplayMember‬ﺇﺫﺍ ﺍﺴﺘﺨﺩﻤﺕ ﺨﺎﺼﻴﺔ ﻤﺼﺩﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﺤﺩﺩﺕ‬

‫ﺠﺩﻭل ﺍﻹﺩﺍﺭﺍﺕ ﻟﻴﻜﻭﻥ ﻫﻭ ﻤﺼﺩﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﻬﺫﻩ ﺍﻟﻘﺎﺌﻤﺔ ﻓﻼ ﺒﺩ ﺃﻥ ﺘﺤﺩﺩ ﺃﻱ ﺤﻘل ﻤﻥ ﻫﺫﺍ‬
‫ﺍﻟﺠﺩﻭل ﺘﺭﻴﺩ ﺃﻥ ﻴﻅﻬﺭ ﻟﻠﻤﺴﺘﺨﺩﻡ ) ﻤﺜﻼ ﻗﺩ ﺘﺭﻴﺩ ﻋﺭﺽ ﺍﺴﻤﺎﺀ ﺍﻹﺩﺍﺭﺍﺕ( ﻫﺫﺍ ﺍﻟﺤﻘل ﺍﻟﺫﻱ‬
‫ﺘﺭﻴﺩ ﻋﺭﻀﻪ ﻟﻠﻤﺴﺘﺨﺩﻡ ﻫﻭ ﻗﻴﻤﺔ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ‪ .‬ﻤﺎﺫﺍ ﻋﻥ ﺃﺭﻗﺎﻡ ﺍﻹﺩﺍﺭﺍﺕ ﻜﻴﻑ ﺘﺤﺼل‬
‫ﻋﻠﻴﻪ ؟ ﻴﻤﻜﻨﻙ ﺫﻟﻙ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺨﺎﺼﻴﺔ ‪)VauleMember‬ﺍﻟﻘﻴﻤﺔ(‪.‬‬
‫‪-٤‬ﺸﻜل ﺍﻟﻅﻬﻭﺭ ‪ :‬ﺘﺤﺩﻴﺩ ﺸﻜل ﺍﻟﻘﺎﺌﻤﺔ ﻫل ﺴﺘﺘﺭﻜﻪ ﻟﻠﻨﻅﺎﻡ ﺃﻡ ﺘﺭﻴﺩ ﺃﻥ ﺘﺘﺤﻜﻡ ﺒﻪ ‪ .‬ﻫﺫﻩ‬
‫ﺍﻟﺨﺎﺼﻴﺔ ﻫﻲ ﺍﻟﺘﻲ ﺘﺤﺩﺩ ﻫﺫﺍ ﺍﻷﻤﺭ‪.‬‬

‫ﺍﻟﻨﻅﺎﻡ ﺴﻭﻑ ﻴﺤﺩﺩ ﺸﻜل ﻋﺭﺽ ﺍﻟﻌﻨﺎﺼﺭ‬ ‫‪Normal‬‬ ‫‪DrawMode‬‬
‫)ﺍﺭﺘﻔﺎﻋﻬﺎ(‪.‬‬
‫ﺍﻟﻤﺴﺘﺨﺩﻡ ﺴﻭﻑ ﻴﺤﺩﺩ ﺸﻜل ﻋﺭﺽ‬ ‫‪OwnerDrawFixed‬‬
‫ﻤﻼﺤﻅﺔﺃﻥ‬ ‫ﻤﻊ‬ ‫)ﺍﺭﺘﻔﺎﻋﻬﺎ(‬ ‫ﺍﻟﻌﻨﺎﺼﺭ‬
‫ﺍﻹﺭﺘﻔﺎﻉ ﺴﻭﻑ ﻴﻜﻭﻥ ﻫﻭ ﻨﻔﺴﻪ ﻟﺠﻤﻴﻊ‬
‫ﺍﻟﻌﻨﺎﺼﺭ ﻭﺫﻟﻙ ﻤﻥ ﺨﻼل ﺍﻟﺨﺎﺼﻴﺔ‬
‫‪.Height‬‬
‫‪ OwnerDrawVariable‬ﺍﻟﻤﺴﺘﺨﺩﻡ ﻫﻭ ﺍﻟﺫﻱ ﻴﺤﺩﺩ ﺸﻜل ﻋﺭﺽ‬
‫ﺍﻟﻌﻨﺎﺼﺭ ﻤﻊ ﻤﻼﺤﻅﺔ ﺃﻨﻙ ﺘﺴﺘﻁﻴﻊ ﺍﻋﻁﺎﺀ‬
‫ﺍﺭﺘﻔﺎﻋﺎﺕ ﻤﺨﺘﻠﻔﺔ ﻟﻠﻌﻨﺎﺼﺭ‪.‬‬
‫‪٩٨‬‬
‫)‪ : (ItemHeight‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻟﺘﺤﺩﻴﺩ ﺍﺭﺘﻔﺎﻉ‬ ‫‪ -٥‬ﺍﺭﺘﻔﺎﻉ ﺍﻟﻌﻨﺼﺭ‬

‫ﺍﻟﻌﻨﺼﺭ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﺇﺫﺍ ﺃﺭﺩﺕ ﺃﻥ ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻓﻼﺒﺩ ﺃﻥ ﺘﻜﻭﻥ ﻗﻴﻤﺔ ﺨﺎﺼﻴﺔ ﺸﻜل ﺍﻟﻅﻬﻭﺭ‬
‫ﺇﺤﺩﻯ ﺍﻟﻘﻴﻤﺘﻴﻥ ﺍﻟﺘﺎﻟﻴﺘﻴﻥ ﺇﻤﺎ ‪ OwnerDrawFixed‬ﺃﻭ ‪ . OwnerDrawVariable‬ﺃﻤﺎ‬
‫ﻗﻴﻤﺔ ‪ Normal‬ﻓﺈﻥ ﺍﻟﻨﻅﺎﻡ ﻫﻭ ﺍﻟﺫﻱ ﻴﺘﺤﻜﻡ ﺒﺎﻹﺭﺘﻔﺎﻉ ﻟﺫﻟﻙ ﻟﻥ ﺘﺴﺘﻔﻴﺩ ﻤﻥ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ‪.‬‬
‫ﻋﻨﺩﻨﺎ ﻫﻨﺎ ﻗﻴﻤﺘﺎﻥ ﻟﻬﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺘﺒﻌﺎ ﻟﻘﻴﻤﺔ ﺨﺎﺼﻴﺔ ﺸﻜل ﺍﻟﻅﻬﻭﺭ ‪:‬‬
‫‪ .I‬ﺇﻥ ﻜﺎﻨﺕ ﻗﻴﻤﺔ ﺨﺎﺼﻴﺔ ﺸﻜل ﺍﻟﻅﻬﻭﺭ ‪ OwnerDrawFixed‬ﻓﺴﻭﻑ ﺘﻜﻭﻥ ﻗﻴﻤﺔ‬
‫ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺍﺭﺘﻔﺎﻉ ﺍﻟﻌﻨﺼﺭ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﻭﺃﻨﺕ ﺨﺒﻴﺭ ﻓﻲ ﺃﻥ ﺇﺭﺘﻔﺎﻉ ﺍﻟﻌﻨﺎﺼﺭ‬
‫ﺴﻭﻑ ﻴﻜﻭﻥ ﻤﻭﺤﺩﺍ ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﻪ ‪.‬‬
‫‪ .II‬ﺇﻥ ﻜﺎﻨﺕ ﻗﻴﻤﺔ ﺨﺎﺼﻴﺔ ﺸﻜل ﺍﻟﻅﻬﻭﺭ ‪ OwnerDrawVariable‬ﻓﺴﻭﻑ ﺘﻜﻭﻥ‬
‫ﻗﻴﻤﺔ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻫﻲ ﺍﺭﺘﻔﺎﻉ ﺁﺨﺭ ﻋﻨﺼﺭ ﺘﻤﺕ ﺇﻀﺎﻓﺘﻪ‪ .‬ﻓﻲ ﺍﻟﻔﺼﻭل ﺍﻟﺘﻁﺒﻴﻘﻴﺔ‬
‫ﺴﻭﻑ ﺘﺘﻤﺭﻥ ﺠﻴﺩﺍ ﻋﻠﻰ ﺍﺴﺘﺨﺩﺍﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ‪.‬‬
‫‪ -٦‬ﺍﻟﻌﻨﺎﺼﺭ )‪ : (Items‬ﺘﻌﺒﺭ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻋﻥ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ‬
‫ﻓﻜل ﻋﻨﺼﺭ ﺒﻬﺎ ﻫﻭ ﺃﺤﺩ ﻋﻨﺎﺼﺭ ﺍﻟﻘﺎﺌﻤﺔ‪ .‬ﺇﺫﺍ ﺃﺭﺩﺕ ﺃﻥ ﺘﺤﻤل ﺍﻟﻌﻨﺎﺼﺭ ﺃﺜﻨﺎﺀ‬
‫ﺍﻟﺘﺼﻤﻴﻡ ﻓﻴﻤﻜﻨﻙ ﺫﻟﻙ ﻤﻥ ﺨﻼل ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺍﻨﻘﺭ ﺍﻟﺯﺭ ﺍﻟﺫﻱ ﻋﻠﻴﻪ ﺜﻼﺙ ﻨﻘﺎﻁ‬
‫ﻟﻴﻅﻬﺭ ﻟﻙ ﺍﻟﺸﻜل )‪ (٢-٩‬ﺍﻜﺘﺏ ﺍﻟﻌﻨﺎﺼﺭ ﻭﺍﻀﻐﻁ ﺯﺭ ﺍﻟﺭﺠﻭﻉ ﺒﻌﺩ ﻜﺘﺎﺒﺔ ﻜل‬
‫ﻋﻨﺼﺭ ﻟﺘﺴﺘﻁﻴﻊ ﻜﺘﺎﺒﺔ ﻋﻨﺼﺭ ﺁﺨﺭ ﻓﻲ ﺴﻁﺭ ﺠﺩﻴﺩ ﺜﻡ ﺍﻨﻘﺭ ﺯﺭ ‪ Ok‬ﻟﺘﻅﻬﺭ ﻟﻙ‬
‫ﺍﻟﻘﺎﺌﻤﺔ ﺒﻌﻨﺎﺼﺭﻫﺎ ﻜﻤﺎ ﻓﻲ ﺍﻟﺸﻜل )‪.(١-٩‬‬
‫ﻜﺎﻨﺕ ﺘﻠﻙ ﻁﺭﻴﻘﺔ ﺘﻌﺒﺌﺔ ﺍﻟﻘﺎﺌﻤﺔ ﺃﺜﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻡ ﻜﺫﻟﻙ ﺘﺴﺘﻁﻴﻊ ﺘﻌﺒﺌﺘﻬﺎ ﺒﻌﺩ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻤﻥ‬
‫ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﺃﻭ ﻤﻥ ﻤﺼﺩﺭ ﺁﺨﺭ ﻭﻫﻭ ﻤﺎﺴﻨﺸﺭﺤﻪ ﻓﻲ ﺍﻟﻔﺼل ﺍﻟﻘﺎﺩﻡ ‪.‬‬
‫ﺷﻜﻞ ‪ ٢-٩‬ﻃﺮﻳﻘﺔ ﺗﻌﺒﺌﺔ ﺍﻟﻘﺎﺋﻤﺔ ﺃﺛﻨﺎﺀ ﺍﻟﺘﺼﻤﻴﻢ‪.‬‬
‫‪٩٩‬‬
‫‪ -٧‬ﺘﻌﺩﺩ ﺍﻷﻋﻤﺩﺓ ‪ :‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻟﺘﺤﺩﻴﺩ ﻤﺎ ﺇﺫﺍ ﻜﺎﻨﺕ ﻫﺫﻩ ﺍﻟﻘﺎﺌﻤﺔ ﺴﻭﻑ ﺘﻌﺭﺽ‬
‫ﺃﻜﺜﺭ ﻤﻥ ﻋﻤﻭﺩ‪.‬‬
‫ﺍﻤﻜﺎﻨﻴﺔ ﻋﺭﺽ ﻋﺩﺓ ﺃﻋﻤﺩﺓ‪.‬‬ ‫‪True‬‬ ‫‪MultiColumn‬‬
‫ﻋﻤﻭﺩ ﻭﺍﺤﺩ ﻓﻘﻁ‪.‬‬ ‫‪False‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﺇﺫﺍ ﻜﺎﻨﺕ ﻗﻴﻤﺔ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ‪ True‬ﺍﺴﺘﺨﺩﻡ ﺨﺎﺼﻴﺔ ‪ ColumnWidth‬ﻟﺘﺤﺩﻴﺩ‬

‫ﻋﺭﺽ ﺍﻟﻌﻤﻭﺩ‪.‬‬
‫‪ -٨‬ﺍﻟﻅﻬﻭﺭ ﺍﻟﺩﺍﺌﻡ ﻟﺸﺭﻴﻁ ﺍﻟﺘﻤﺭﻴﺭ ‪ :‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻹﻅﻬﺎﺭ ﺸﺭﻴﻁ ﺍﻟﺘﻤﺭﻴﺭ ﺩﺍﺌﻤﺎ‬
‫ﺒﻐﺽ ﺍﻟﻨﻅﺭ ﻋﻥ ﻋﺩﺩ ﺍﻟﻌﻨﺎﺼﺭ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ‪.‬‬
‫ﺍﻤﻜﺎﻨﻴﺔ ﻋﺭﺽ ﻋﺩﺓ ﺃﻋﻤﺩﺓ‪.‬‬ ‫‪True ScrollAlwaysVisible‬‬
‫ﻋﻤﻭﺩ ﻭﺍﺤﺩ ﻓﻘﻁ‪.‬‬ ‫‪False‬‬
‫‪ -٩‬ﻁﺭﻴﻘﺔ ﺍﻹﺨﺘﻴﺎﺭ ‪ :‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻟﺘﺤﺩﻴﺩ ﻤﺎ ﺇﺫﺍ ﻜﺎﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻴﺴﺘﻁﻴﻊ ﺇﺨﺘﻴﺎﺭ‬
‫ﻋﻨﺼﺭ ﺃﻭ ﺃﻜﺜﺭ ﺃﻭ ﻻﻴﺴﺘﻁﻴﻊ ﺇﺨﺘﻴﺎﺭ ﺃﻱ ﻋﻨﺼﺭ‪.‬‬

‫ﻻﻴﺴﺘﻁﻴﻊ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺍﺨﺘﻴﺎﺭ ﺃﻱ ﻋﻨﺼﺭ ﻤﻥ‬ ‫‪None‬‬ ‫‪SelectionMode‬‬
‫ﺍﻟﻘﺎﺌﻤﺔ‬
‫ﻴﺴﺘﻁﻴﻊ ﺍﺨﺘﻴﺎﺭ ﻋﻨﺼﺭ ﻭﺍﺤﺩ ﻓﻘﻁ‬ ‫‪One‬‬
‫ﺍﻨﻅﺭ‬ ‫ﻋﻨﺼﺭ‬ ‫ﻤﻥ‬ ‫ﺃﻜﺜﺭ‬ ‫ﺍﺨﺘﻴﺎﺭ‬ ‫ﻴﺴﺘﻁﻴﻊ‬ ‫‪MultiSimple‬‬
‫ﺸﻜل )‪(٣-٩‬‬
‫ﻋﻨﺼﺭ ﺍﻨﻅﺭ‬ ‫ﻤﻥ‬ ‫ﺃﻜﺜﺭ‬ ‫ﺍﺨﺘﻴﺎﺭ‬ ‫‪ MultiExtended‬ﻴﺴﺘﻁﻴﻊ‬
‫ﺸﻜل )‪(٣-٩‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﺍﻟﻔﺭﻕ ﺒﻴﻥ ‪) MultiSimple‬ﺍﻹﺨﺘﻴﺎﺭ ﺍﻟﺒﺴﻴﻁ( ﻭ ‪) MultiExtended‬ﺍﻹﺨﺘﻴﺎﺭ‬

‫ﺍﻟﻤﻁﻭﺭ( ﺃﻥ ﺍﻹﺨﺘﻴﺎﺭ ﺍﻟﻤﻁﻭﺭ ﻴﻤﻜﻨﻙ ﻤﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺯﺭ ‪ Shift‬ﻭ ‪ Ctrl‬ﻹﺨﺘﻴﺎﺭ ﻤﺘﻌﺩﺩ ﺒﻌﻜﺱ‬
‫ﺍﻹﺨﺘﻴﺎﺭ ﺍﻟﺒﺴﻴﻁ ﺍﻟﺫﻱ ﻴﺘﻭﺠﺏ ﻋﻠﻴﻙ ﺍﻟﻨﻘﺭ ﻋﻠﻰ ﻜل ﻋﻨﺼﺭ ﻹﺨﺘﻴﺎﺭﻩ‪.‬‬
‫‪١٠٠‬‬
‫ﺷﻜﻞ ‪ ٣-٩‬ﺍﻹﺧﺘﻴﺎﺭ ﺍﳌﺘﻌﺪﺩ‬
‫‪ -١٠‬ﺍﻟﺘﺭﺘﻴﺏ ‪ :‬ﺘﺴﺘﺨﺩﻡ ﻟﻠﺘﺭﺘﻴﺏ ﺍﻟﺘﻠﻘﺎﺌﻲ ﻟﻠﻌﻨﺎﺼﺭ‪.‬‬

‫ﺘﺭﺘﻴﺏ ﺤﺴﺏ ﺤﺭﻭﻑ ﺍﻟﻬﺠﺎﺀ‪.‬‬ ‫‪True‬‬ ‫‪Sorted‬‬
‫ﺘﺭﺘﻴﺏ ﺤﺴﺏ ﺘﺤﻤﻴل ﺍﻟﻌﻨﺎﺼﺭ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ‪.‬‬ ‫‪False‬‬
‫‪ -١١‬ﺍﻟﻘﻴﻤﺔ ‪ :ValueMember‬ﺍﺭﺠﻊ ﺍﻟﺨﺎﺼﻴﺔ ‪٣‬‬
‫‪١٠١‬‬
‫ﺍﻷﺩﺍﺓ ﺍﻟﻤﺭﻜﺒﺔ)‪(Combo Box‬‬
‫ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻷﺩﺍﺓ ﻟﻌﺩﺓ ﺃﻏﺭﺽ ﻤﻨﻬﺎ ﺃﻨﻪ ﻴﻤﻜﻥ ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﻜﺄﺩﺍﺓ ﻨﺹ ﺃﻭ ﻗﺎﺌﻤﺔ‬
‫ﻤﻨﺴﺩﻟﺔ ﺃﻭ ﻗﺎﺌﻤﺔ ﻋﺎﺩﻴﺔ ﻤﺜل ﺃﺩﺍﺓ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﺴﺎﺒﻘﺔ‪.‬‬
‫ﺇﺫﺍ ﺃﺭﺩﺕ ﻋﺭﺽ ﻗﺎﺌﻤﺔ ﺃﺴﻤﺎﺀ ﺍﻟﻤﺩﻥ ﺃﻭ ﺍﻹﺩﺍﺭﺍﺕ ﺃﻭ ﻏﻴﺭﻫﺎ ﻤﻥ ﺍﻟﻘﻭﺍﺌﻡ‪ .‬ﺃﻭ ﺇﻀﺎﻓﺔ‬ ‫ﻤﺜﺎل‬
‫ﺇﺩﺍﺭﺍﺕ ﺠﺩﻴﺩﺓ ﻴﻤﻜﻨﻙ ﺫﻟﻙ ﻋﻥ ﻁﺭﻴﻕ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻓﻲ ﺍﻟﻐﺎﻟﺏ ﺘﺴﺘﺨﺩﻡ ﺍﻟﻘﺎﺌﻤﺔ ﻋﻨﺩﻤﺎ ﻴﻜﻭﻥ ﻋﺩﺩ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺘﻲ ﺴﺘﻌﺭﺽ ﻗﻠﻴل ﺒﻴﻨﻤﺎ‬
‫ﺘﺴﺘﺨﺩﻡ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻤﻨﺴﺩﻟﺔ ﺇﺫﺍ ﻜﺎﻥ ﻋﺩﺩ ﺍﻟﻌﻨﺎﺼﺭ ﻀﺨﻤﺎ‪.‬‬
‫ﺨﺼﺎﺌﺹ ﺍﻷﺩﺍﺓ ﺍﻟﻤﺭﻜﺒﺔ ‪ :‬ﺍﻟﻜﻼﻡ ﻓﻴﻬﺎ ﻨﻔﺱ ﺍﻟﻜﻼﻡ ﻋﻥ ﺨﺼﺎﺌﺹ ﺃﺩﺍﺓ ﺍﻟﻘﺎﺌﻤﺔ ﻤﻊ ﺯﻴﺎﺩﺓ‬
‫ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ﻭﻫﻲ ‪:‬‬
‫‪ -١‬ﺍﻟﻌﺩﺩ ﺍﻷﻗﺼﻰ ﻟﻠﻌﻨﺎﺼﺭ‪ :‬ﺃﻜﺒﺭ ﻋﺩﺩ ﻤﻤﻜﻥ ﻤﻥ ﺍﻟﻌﻨﺎﺼﺭ ﻴﻤﻜﻥ ﻋﺭﻀﻪ ﻋﻨﺩ ﺍﻨﺴﺩﺍل‬
‫ﺍﻟﻘﺎﺌﻤﺔ‪ .‬ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪ (٤-٩‬ﻤﻊ ﻤﻼﺤﻅﺔ ﺃﻨﻙ ﺘﺴﺘﻁﻴﻊ ﺍﻟﻭﺼﻭل ﻟﺒﺎﻗﻲ ﺍﻟﻌﻨﺎﺼﺭ‬
‫ﺒﻭﺍﺴﻁﺔ ﺃﺸﺭﻁﺔ ﺍﻟﺘﻤﺭﻴﺭ‪.‬‬
‫= ‪Style‬‬ ‫‪ Style = DropDown‬ﺃﻭ‬ ‫ﻤﻼﺤﻅﺔ ‪ :‬ﻻﺒﺩ ﺃﻥ ﺘﻜﻭﻥ ﺨﺎﺼﻴﺔ‬
‫‪ DropDownList‬ﺤﺘﻰ ﺘﺘﻤﻜﻥ ﻤﻥ ﺍﺴﺘﺨﺩﺍﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ‪.‬‬

‫ﻋﺩﺩ ﺍﻟﻌﻨﺎﺼﺭ ﻋﻨﺩ ﺍﻨﺴﺩﺍل ﺍﻟﻘﺎﺌﻤﺔ‪.‬‬ ‫‪ MaxDropDownItems‬ﻋﺩﺩ ﺼﺤﻴﺢ‬
‫ﺷﻜﻞ ‪ 0٤-٩‬ﻋﻨﺪﻣﺎ ﺟﻌﻠﻨﺎ ﻗﻴﻤﺔ ﺍﻟﻌﺪﺩ ﺍﻷﻗﺼﻰ ﻣﻦ ﺍﻟﻌﻨﺎﺻﺮ ﺍﳌﻨﺴﺪﻟﺔ = ‪٢‬‬
‫‪١٠٢‬‬
‫‪ -٢‬ﺍﻟﻨﻤﻁ ﺃﻭ ﺍﻟﺸﻜل ‪ :‬ﺘﺴﺘﺨﺩﻡ ﻟﻠﺘﺤﻜﻡ ﺒﺸﻜل ﻭﺃﺩﺍﺀ ﺍﻷﺩﺍﺓ ﺍﻟﻤﺭﻜﺒﺔ‪.‬ﺍﻨﻅﺭ ﺸﻜل )‪(٥-٩‬‬
‫ﻟﻤﻌﺭﻓﺔ ﺍﻟﻔﺭﻕ ﺒﻴﻥ ﺍﻟﻘﻴﻡ ﺍﻟﺜﻼﺙ ﻟﻬﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ‪.‬‬

‫ﺘﻜﻭﻥ ﻓﻴﻪ ﺍﻷﺩﺍﺓ ﺍﻟﻤﺭﻜﺒﺔ ﻤﺸﺎﺒﻬﻪ ﻟﻤﺭﺒﻊ‬ ‫‪Simple‬‬ ‫‪Style‬‬
‫ﺍﻟﻨﺹ‪.‬‬
‫ﻗﺎﺌﻤﺔ ﻤﻨﺴﺩﻟﺔ ﻴﺴﺘﻁﻴﻊ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻜﺘﺎﺒﺔ ﻨﺹ‬ ‫‪DropDown‬‬
‫ﻓﻲ ﻤﻜﺎﻥ ﺍﻟﺘﺤﺭﻴﺭ‪.‬‬
‫‪ DropDownList‬ﺃﺸﺒﻪ ﻤﺎﺘﻜﻭﻥ ﺒﺄﺩﺍﺓ ﺍﻟﻘﺎﺌﻤﺔ ‪ .‬ﺍﻟﻤﺴﺘﺨﺩﻡ ﻟﻴﺱ‬
‫ﻟﺩﻴﻪ ﺇﻻ ﺨﻴﺎﺭ ﺍﻹﺨﺘﻴﺎﺭ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ‪.‬‬
‫ﺷﻜﻞ ‪ ٥-٩‬ﻳﻈﻬﺮ ﻟﻚ ﺍﻟﻔﺮﻕ ﺑﲔ ﺍﻟﻘﻴﻢ ﺍﻟﺜﻼﺙ ﳋﺎﺻﻴﺔ ﺍﻟﻨﻤﻂ‬
‫‪١٠٣‬‬
‫ﻗﺎﺌﻤﺔ ﻤﺭﺒﻊ ﺍﻟﺨﻴﺎﺭ )‪(CheckedListBox‬‬
‫ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﺘﻌﺘﺒﺭ ﻫﺫﻩ ﺍﻷﺩﺍﺓ ﺍﻤﺘﺩﺍﺩﺍ ﻷﺩﺍﺓ ﺍﻟﻘﺎﺌﻤﺔ‪ .‬ﺘﺴﺘﺨﺩﻡ ﺒﺎﻟﻀﺒﻁ ﻜﻤﺎ ﺘﺴﺘﺨﺩﻡ ﺃﺩﺍﺓ ﺍﻟﻘﺎﺌﻤﺔ ﻟﻜﻥ‬
‫ﻜل ﻋﻨﺼﺭ ﻤﻥ ﻫﺫﻩ ﺍﻷﺩﺍﺓ ﻴﺒﺩﻭﺍ ﻜﺄﻨﻪ ﻤﺭﺒﻊ ﻨﺹ ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪(٦-٩‬‬
‫ﺇﺫﺍ ﺃﺭﺩﺕ ﺃﻥ ﺘﻌﺭﺽ ﻗﺎﺌﻤﺔ ﺍﻟﻁﻼﺏ ﻭﺘﺭﻴﺩ ﺃﻥ ﻴﻅﻬﺭ ﺃﻤﺎﻡ ﺍﻟﻁﺎﻟﺏ ﺍﻟﻨﺎﺠﺢ ﻋﻼﻤﺔ ‪9‬‬ ‫ﻤﺜﺎل‬
‫ﻭﺃﻤﺎ ﺍﻟﻁﺎﻟﺏ ﻏﻴﺭ ﺍﻟﻨﺎﺠﺢ ﻓﻼ ﻴﻅﻬﺭ ﺒﺠﺎﻨﺒﻪ ﻋﻼﻤﺔ‪ .‬ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪(٦-٩‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻴﻭﺠﺩ ﺍﺨﺘﻼﻓﺎﺕ ﻓﻲ ﺒﻌﺽ ﺍﻟﺨﺼﺎﺌﺹ ﺒﻴﻥ ﺃﺩﺍﺓ ﺍﻟﻘﺎﺌﻤﺔ ﻭﺃﺩﺍﺓ ﻗﺎﺌﻤﺔ ﻤﺭﺒﻊ ﺍﻹﺨﺘﻴﺎﺭ ﺘﺒﻌﺎ‬
‫ﻹﻀﺎﻓﺔ ﻤﺭﺒﻊ ﺍﻹﺨﺘﻴﺎﺭ‬
‫ﺷﻜﻞ ‪ : ٦-٩‬ﻗﺎﺋﻤﺔ ﻣﺮﺑﻊ ﺍﳋﻴﺎﺭ‬
‫ﺨﺼﺎﺌﺹ ﻗﺎﺌﻤﺔ ﻤﺭﺒﻊ ﺍﻟﺨﻴﺎﺭ ‪ :‬ﺍﻟﻜﻼﻡ ﻓﻴﻬﺎ ﻨﻔﺱ ﺍﻟﻜﻼﻡ ﻋﻥ ﺨﺼﺎﺌﺹ ﺃﺩﺍﺓ ﺍﻟﻘﺎﺌﻤﺔ ﻤﻊ ﺯﻴﺎﺩﺓ‬
‫ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ﻭﻫﻲ ‪:‬‬
‫ﺃﻫﻡ ﺨﺎﺼﻴﺔ ﻴﻤﻜﻥ ﺫﻜﺭﻫﺎ ﻫﻨﺎ ﻫﻲ ﺨﺎﺼﻴﺔ ﺍﻟﻌﺩﺩ ﺍﻷﻗﺼﻰ ﻟﻠﻌﻨﺎﺼﺭ ‪ :‬ﺃﻜﺒﺭ ﻋﺩﺩ‬
‫ﻤﻤﻜﻥ ﻤﻥ ﺍﻟﻌﻨﺎﺼﺭ ﻴﻤﻜﻥ ﻋﺭﻀﻪ ﻋﻨﺩ ﺍﻨﺴﺩﺍل ﺍﻟﻘﺎﺌﻤﺔ‪ .‬ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪ (٧-٩‬ﻤﻊ‬
‫ﻤﻼﺤﻅﺔ ﺃﻨﻙ ﺘﺴﺘﻁﻴﻊ ﺍﻟﻭﺼﻭل ﻟﺒﺎﻗﻲ ﺍﻟﻌﻨﺎﺼﺭ ﺒﻭﺍﺴﻁﺔ ﺃﺸﺭﻁﺔ ﺍﻟﺘﻤﺭﻴﺭ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻻﺒﺩ ﺃﻥ ﺘﻜﻭﻥ ﺨﺎﺼﻴﺔ ‪ Style = DropDown‬ﺃﻭ = ‪Style‬‬
‫‪ DropDownList‬ﺤﺘﻰ ﺘﺘﻤﻜﻥ ﻤﻥ ﺍﺴﺘﺨﺩﺍﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ‪.‬‬
‫‪١٠٤‬‬

‫ﻋﺩﺩ ﺍﻟﻌﻨﺎﺼﺭ ﻋﻨﺩ ﺍﻨﺴﺩﺍل ﺍﻟﻘﺎﺌﻤﺔ‪.‬‬ ‫‪ MaxDropDownItems‬ﻋﺩﺩ ﺼﺤﻴﺢ‬
‫ﺷﻜﻞ‪ ٧-٩ :‬ﻋﻨﺪﻣﺎ ﺟﻌﻠﻨﺎ ﻗﻴﻤﺔ ﺍﻟﻌﺪﺩ ﺍﻷﻗﺼﻰ ﻣﻦ ﺍﻟﻌﻨﺎﺻﺮ ﺍﳌﻨﺴﺪﻟﺔ = ‪٢‬‬
‫‪١٠٥‬‬
‫ﺍﻟﺩﺭﺱ ﺍﻟﺜﺎﻟﺙ‬
‫ﺒﺩﺍﻴﺔ ﺤﻘﻴﻘﻴﺔ ﻟﻜﺘﺎﺒﺔ ﺍﻟﺒﺭﺍﻤﺞ‬
‫ﺒﺭﻨﺎﻤﺞ ﻗﺎﺌﻤﺔ ﺍﻷﺴﻤﺎﺀ‬
‫ﺴﻭﻑ ﻨﻘﻭﻡ ﻓﻲ ﺍﻟﺘﺩﺭﻴﺏ ﺍﻟﺘﺎﻟﻲ ﺒﺩﺍﻴﺔ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻘﻭﺍﺌﻡ ﻭﻫﻲ ﻤﻥ ﺍﻷﺩﻭﺍﺕ ﺍﻟﻤﻬﻤﺔ‬ ‫ﺍﻟﻬﺩﻑ‬
‫ﻓﻲ ‪ vb.net‬ﻜﺫﻟﻙ ﺴﻭﻑ ﺘﺘﺩﺭﺏ ﺃﻜﺜﺭ ﻋﻠﻰ ﻜﺘﺎﺒﺔ ﻋﺒﺎﺭﺍﺕ ﺒﺭﻤﺠﻴﺔ ﻤﻤﺎ ﻴﻌﻁﻴﻙ‬
‫ﺍﻟﻘﺩﺭﺓ ﻋﻠﻰ ﺒﺩﺀ ﺍﻟﺘﻔﻜﻴﺭ ﺒﺭﻤﺠﻴﺎ‪.‬‬
‫ﻨﻤﻭﺫﺝ ﻭﺴﻭﻑ ﻨﻀﻴﻑ ﺇﻟﻴﻪ ﻤﺭﺒﻊ ﻗﺎﺌﻤﺔ –‪ -ListBox‬ﻭ ﺃﺭﺒﻊ ﺃﺯﺭﺍﺭ ﺃﻤﺭ ﻭﺃﺩﺍﺓ‬ ‫ﺍﻷﺩﻭﺍﺕ‬
‫ﻋﻨﻭﺍﻥ ﻭﺃﺩﺍﺓ ﻨﺹ ﺍﻨﻅﺭ ﺸﻜل )‪(٨-٩‬‬
‫ﺴﺘﻜﻭﻥ ﺍﻟﻌﻤﻠﻴﺔ ﻜﺎﻟﺘﺎﻟﻲ ‪ .‬ﺴﻭﻑ ﺘﻜﺘﺏ ﺍﺴﻡ ﻓﻲ ﺃﺩﺍﺓ ﺍﻟﻨﺹ ﺜﻡ ﺘﻨﻘﺭ ﺯﺭ ﺍﻀﺎﻓﺔ ﺃﻭ‬ ‫ﺍﻟﻨﺎﺘﺞ‬
‫ﺘﻀﻐﻁ ﺯﺭ ﺍﻟﺭﺠﻭﻉ – ‪ -Enter‬ﺜﻡ ﺴﻴﻨﺘﻘل ﻤﺎﻜﺘﺒﺘﻪ ﻤﻥ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺇﻟﻰ ﺍﻟﻘﺎﺌﻤﺔ ‪.‬‬
‫ﻋﻨﺩ ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺃﻱ ﺍﺴﻡ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﺴﻭﻑ ﻴﻅﻬﺭ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻟﻴﻤﻜﻨﻙ ﻤﻥ‬
‫ﺘﻌﺩﻴﻠﻪ ﺇﺫﺍ ﺃﺭﺩﺕ ﺜﻡ ﻀﻐﻁ ﺯﺭ ﺘﻌﺩﻴل ﻟﻴﻌﻴﺩﻩ ﺇﻟﻰ ﺍﻟﻘﺎﺌﻤﺔ ﺒﻌﺩ ﺍﻟﺘﻌﺩﻴل‪ .‬ﻟﺤﺫﻑ ﺃﻱ ﺍﺴﻡ‬
‫ﺍﺨﺘﺭ ﺍﻹﺴﻡ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﺜﻡ ﺍﻨﻘﺭ ﻋﻠﻰ ﺯﺭ ﺤﺫﻑ ﺴﺘﻅﻬﺭ ﻟﻙ ﺭﺴﺎﻟﺔ ﺘﺄﻜﻴﺩﻴﺔ ﺍﺨﺘﺭ‬
‫‪ Yes‬ﻟﻠﺤﺫﻑ ﺃﻭ ‪ No‬ﻹﻟﻐﺎﺀ ﺃﻤﺭ ﺍﻟﺤﺫﻑ‪ .‬ﻟﻠﺨﺭﻭﺝ ﺍﻨﻘﺭ ﻋﻠﻰ ﺯﺭ ﺨﺭﻭﺝ‪ .‬ﺍﻨﻅﺭ‬
‫ﺍﻟﺸﻜﻠﻴﻥ )‪ (٩-٩‬ﻭ )‪(١٠-٩‬‬
‫‪١٠٦‬‬
kal_judaia@hotmail.com ‫ﺧﺎﻟﺪ ﺍﳉﺪﻳﻊ‬

‫ﻏﻴﺭ ﺨﺼﺎﺌﺹ ﺍﻷﺩﻭﺍﺕ ﻟﺘﺼﺒﺢ ﻤﻁﺎﺒﻘﺔ ﻟﻠﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ﺍﻨﻅﺭ‬ ‫ ﻭﻀﻊ ﺍﻷﺩﻭﺍﺕ‬-١
(٨-٩) ‫ﺍﻟﺸﻜل‬ ‫ﻭﺘﻌﺩﻴل ﺍﻟﺨﺼﺎﺌﺹ‬

‫ﺍﻟﻤﻁﻠﻭﺒﺔ ﺃﺜﻨﺎﺀ‬
‫ﺍﻟﺘﺼﻤﻴﻡ‬
LblName Name Label1
‫ﺍﻻﺴﻡ‬ Text
txtName Name Text1
Text
cmdAdd Name Button1
‫ﺍﻀﺎﻓﺔ‬ Text
cmdUpdate Name Button2
‫ﺘﻌﺩﻴل‬ Text
CmdDelete Name Button3
‫ﺤﺫﻑ‬ Text
CmdExit Name Button4
‫ﺨﺭﻭﺝ‬ Text
LstName Name ListBox
Right RightToLeft Form1
cmdAdd AcceptButton
Moccasin BackColor
‫ ﺑﺪﺀ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﻟﻘﻮﺍﺋﻢ‬:٨-٩ ‫ﺷﻜﻞ‬
‫ﺍﻟﺒﺩﺀ ﻓﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ‬ ‫ ﻨﺤﻥ ﻨﺭﻴﺩ ﺍﻵﻥ‬-٢

‫ﺇﻀﺎﻓﺔ ﻤﺎﻴﻜﺘﺒﻪ‬
١٠٧
‫ﺍﻨﻘﺭ ﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺯﺭ ﺍﻀﺎﻓﺔ‪ .‬ﻭﺍﻜﺘﺏ ﺍﻟﺘﺎﻟﻲ ‪:‬‬ ‫ﺍﻟﻤﺴﺘﺨﺩﻡ ﻓﻲ ﻤﺭﺒﻊ‬

‫‪If txtname.Text <> "" Then‬‬ ‫ﺍﻷﻤﺭ ﺇﻟﻰ ﺃﺩﺍﺓ ﺍﻟﻘﺎﺌﻤﺔ‬
‫)‪lstname.Items.Add(txtname.Text‬‬ ‫ﻟﻴﺼﺒﺢ ﻋﻨﺼﺭﺍ ﻤﻥ‬
‫)(‪txtname.ResetText‬‬ ‫ﻋﻨﺎﺼﺭﻫﺎ‪ .‬ﻟﻜﻲ ﻨﻔﻌل‬

‫ﺫﻟﻙ ﻻﺒﺩ ﻤﻥ ﺃﺭﺒﻊ‬
‫)(‪txtname.Focus‬‬
‫ﺨﻁﻭﺍﺕ ﻭﻫﻲ ﺃﻭﻻ ‪:‬‬
‫‪End If‬‬
‫ﺍﻟﺘﺄﻜﺩ ﻤﻥ ﺃﻥ‬
‫ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻷﻭل ﻨﺘﺄﻜﺩ ﻤﻥ ﺃﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺃﺩﺨل ﺍﺴﻡ ﻓﻲ ﻤﺭﺒﻊ‬
‫ﺍﻟﻤﺴﺘﺨﺩﻡ ﻜﺘﺏ ﺸﻴﺌﺎ‬
‫ﺍﻟﻨﺹ‪ .‬ﻓﻨﺘﺄﻜﺩ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺨﺎﺼﻴﺔ ‪ Text‬ﻷﻨﻬﺎ ﻫﻲ ﺍﻟﺘﻲ ﺘﺤﻭﻱ‬
‫ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ‪ .‬ﺜﺎﻨﻴﺎ‬
‫ﻤﺎﻴﺩﺨل ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻓﺈﺫﺍ ﻜﺎﻨﺕ "" ﻓﻴﻌﻨﻲ ﺃﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻟﻡ ﻴﺩﺨل‬ ‫‪ :‬ﻋﻤﻠﻴﺔ ﺍﻹﻀﺎﻓﺔ‪.‬‬
‫ﺸﻲﺀ‪.‬‬ ‫ﺜﺎﻟﺜﺎ ‪ :‬ﻤﺴﺢ ﻤﺎﻫﻭ‬
‫ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻨﻲ ﻨﺴﺘﺨﺩﻡ ﺍﻟﺩﺍﻟﺔ ‪ Add‬ﻟﻺﻀﺎﻓﺔ ﻟﻠﻘﺎﺌﻤﺔ‪ .‬ﺒﺎﻟﻁﺒﻊ ﻻﺒﺩ‬ ‫ﻤﻭﺠﻭﺩ ﻓﻲ ﻤﺭﺒﻊ‬
‫ﺃﻥ ﺘﻌﻁﻲ ﻫﺫﻩ ﺍﻟﺩﺍﻟﺔ ﻤﺎﺘﺭﻴﺩ ﺍﻀﺎﻓﺘﻪ‪ .‬ﻓﻲ ﻤﺜﺎﻟﻨﺎ ﻫﺫﺍ ﻨﺤﻥ ﻨﺭﻴﺩ ﺍﻀﺎﻓﺔ‬ ‫ﺍﻟﻨﺹ ﻹﻀﺎﻓﺔ ﻋﻨﺼﺭ‬
‫ﺁﺨﺭ‪ .‬ﺃﺨﻴﺭﺍ ‪ :‬ﺍﻟﺘﺭﻜﻴﺯ‬
‫ﺍﻻﺴﻡ ﺍﻟﺫﻱ ﻴﺩﺨﻠﻪ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻟﺫﻟﻙ ﺃﻋﻁﻴﻨﺎ ﻫﺫﻩ ﺍﻟﺩﺍﻟﺔ‬
‫ﻋﻠﻰ ﻤﺭﺒﻊ ﺍﻟﻨﺹ‬
‫ﺍﻻﺴﻡ ﺍﻟﺫﻱ ﺃﺩﺨﻠﻪ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻭﻫﻭ ﻤﻭﺠﻭﺩ ﻓﻲ ﺍﻟﺨﺎﺼﻴﺔ ‪Text‬‬
‫ﺍﺴﺘﻌﺩﺍﺩ ﻟﻠﻜﺘﺎﺒﺔ‪.‬‬
‫ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻟﺙ ﺍﺴﺘﺨﺩﻤﻨﺎ ﺍﻟﺩﺍﻟﺔ ‪ ResetText‬ﻭﺍﻟﺘﻲ ﺘﺯﻴل ﺍﻻﺴﻡ‬
‫ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻟﻜﻲ ﻨﺘﻤﻜﻥ ﻤﻥ ﺍﺩﺨﺎل ﺍﺴﻡ ﺁﺨﺭ‬
‫ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺭﺍﺒﻊ ﺍﺴﺘﺨﺩﻤﻨﺎ ﺍﻟﺩﺍﻟﺔ ‪ Focus‬ﻟﻜﻲ ﻴﻌﻭﺩ ﺍﻟﻤﺅﺸﺭ ﺇﻟﻰ‬
‫ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻟﻨﺘﻤﻜﻥ ﻤﻥ ﻜﺘﺎﺒﺔ ﺍﺴﻡ ﺁﺨﺭ‬
‫ﺍﻟﺴﻁﺭ ﺍﻷﺨﻴﺭ ﻨﻐﻠﻕ ﺠﻤﻠﺔ ﺍﻟﺸﺭﻁ ‪If‬‬
‫ﺍﻨﻘﺭ ﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺍﻟﻘﺎﺌﻤﺔ ﻭﺍﻜﺘﺏ ﺍﻟﺘﺎﻟﻲ‬ ‫‪ -٣‬ﺍﻅﻬﺎﺭ ﺍﻟﻌﻨﺼﺭ‬

‫‪txtname.Text = lstname.SelectedItem.ToString‬‬ ‫ﺍﻟﺫﻱ ﻴﺨﺘﺎﺭﻩ ﺍﻟﻤﺴﺘﺨﺩﻡ‬
‫ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﻓﻲ ﻤﺭﺒﻊ‬
‫ﻓﻲ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ ﻨﻌﺭﺽ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺫﻱ ﺍﺨﺘﺎﺭﻩ‬ ‫ﺍﻟﻨﺹ‬
‫ﺍﻟﻤﺴﺘﺨﺩﻡ‪ .‬ﻷﻨﻨﺎ ﻨﻜﺘﺏ ﻫﺫﻩ ﺍﻟﻌﺒﺎﺭﺓ ﻋﻨﺩ ﺍﻟﺤﺩﺙ‬
‫ﻓﺈﻥ ﻗﻴﻤﺔ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺘﺘﻐﻴﺭ ﻜﻠﻤﺎ‬ ‫‪SelectedIndexChanged‬‬
‫ﻏﻴﺭ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺍﻻﺴﻡ ﺍﻟﺫﻱ ﻴﺨﺘﺎﺭﻩ‪.‬‬
‫ﻓﻠﻭ ﻨﻘﺭ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﺍﻻﺴﻡ ﻤﺤﻤﺩ ﻅﻬﺭ ﻟﻨﺎ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻤﺤﻤﺩ‬
‫ﺜﻡ ﻨﻘﺭ ﻋﻠﻰ ﺨﺎﻟﺩ ﻅﻬﺭ ﻟﻨﺎ ﺨﺎﻟﺩ‪.‬‬
‫ﻤﻼﺤﻅﻪ ‪ :‬ﺍﻟﺤﺩﺙ ‪ SelectedIndexChanged‬ﻴﺘﻡ ﺘﻨﻔﻴﺫﻩ ﻜﻠﻤﺎ‬
‫‪١٠٨‬‬
‫ﺍﻨﺘﻘل ﺍﻟﻤﺴﺘﺨﺩﻡ ﻤﻥ ﻋﻨﺼﺭ ﺇﻟﻰ ﺁﺨﺭ ﺴﻭﺍﺀ ﺒﺎﻟﻔﺄﺭﺓ ﺃﻭ ﺍﻷﺴﻬﻡ ﺃﻭ‬

‫ﺃﻱ ﻁﺭﻴﻘﺔ ﻜﺎﻨﺕ‪.‬‬
‫‪ -٤‬ﺘﻌﺩﻴل ﺃﺤﺩ ﻋﻨﺎﺼﺭ ﺍﻨﻘﺭ ﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺯﺭ ﺍﻟﺘﻌﺩﻴل ﻭﺍﻜﺘﺏ ﺍﻟﺘﺎﻟﻲ‬

‫‪If lstname.SelectedIndex <>-1 Then‬‬ ‫ﺍﻟﻘﺎﺌﻤﺔ ﻴﺘﻡ ﺒﺄﺭﺒﻊ‬
‫)‪lstname.Items.Remove(lstname.SelectedIndex‬‬ ‫ﺨﻁﻭﺍﺕ‪ .‬ﺃﻭﻻ ‪ :‬ﺍﻟﺘﺄﻜﺩ‬
‫)‪lstname.Items.Add(txtname.Text‬‬ ‫ﻤﻥ ﺃﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ‬
‫)(‪txtname.ResetText‬‬
‫ﺍﺨﺘﺎﺭ ﻋﻨﺼﺭﺍ ﻤﻥ‬
‫‪End If‬‬
‫ﺍﻟﻘﺎﺌﻤﺔ ﻟﺘﻌﺩﻴﻠﺔ‪ .‬ﺜﺎﻨﻴﺎ ‪:‬‬
‫ﻓﻲ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻷﻭﻟﻰ ﻨﺘﺄﻜﺩ ﻤﻥ ﺃﻥ ﻫﻨﺎﻙ ﺍﺴﻡ ﻤﺨﺘﺎﺭ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ‪ .‬ﻜﻤﺎ‬
‫ﺤﺫﻑ ﺍﻟﻌﻨﺼﺭ ﻤﻥ‬
‫ﺘﺫﻜﺭ ﻤﻥ ﺍﻟﻔﺼل ﺍﻷﻭل ﺃﻥ ﻗﻴﻤﺔ ‪ SelectedIndex‬ﺘﻜﻭﻥ –‪ ١‬ﺇﺫﺍ ﻟﻡ‬
‫ﺍﻟﻘﺎﺌﻤﺔ‪ .‬ﺜﺎﻟﺜﺎ ﻭﻀﻊ‬
‫ﻴﺨﺘﺭ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺃﻱ ﻋﻨﺼﺭ‪.‬‬
‫ﺍﻟﻌﻨﺼﺭ ﺍﻟﺠﺩﻴﺩ ﺒﺩﻻ‬
‫‪ Remove‬ﻟﺤﺫﻑ ﻋﻨﺼﺭ ﻤﻥ‬ ‫ﻓﻲ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺜﺎﻨﻴﺔ ﻨﺴﺘﺨﺩﻡ ﺍﻟﺩﺍﻟﺔ‬ ‫ﻤﻨﻪ‪ .‬ﺃﺨﻴﺭﺍ ‪ :‬ﻤﺴﺢ‬
‫ﺍﻟﻘﺎﺌﻤﺔ‪ .‬ﻤﻥ ﺍﻟﺒﺩﻴﻬﻲ ﺃﻥ ﻫﺫﻩ ﺍﻟﺩﺍﻟﺔ ﺘﻁﻠﺏ ﺭﻗﻡ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺫﻱ ﻨﺭﻴﺩ‬ ‫ﻤﺎﻫﻭ ﻤﻭﺠﻭﺩ ﻓﻲ‬
‫ﺤﺫﻓﻪ‪ .‬ﻭﺃﻨﺕ ﺘﻌﻠﻡ ﺃﻥ‬ ‫ﻤﺭﺒﻊ ﺍﻟﻨﺹ‬
‫ﺍﻟﻌﺒﺎﺭﺓ ‪ lstname.SelectedIndex‬ﺘﻌﻁﻴﻨﺎ ﺭﻗﻡ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺤﺎﻟﻲ‬

‫ﺃﻱ ﺍﻟﺫﻱ ﻨﻘﺭ ﻋﻠﻴﻪ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻟﺫﻟﻙ ﻓﻨﺤﻥ ﻨﺭﺴﻠﻪ ﺇﻟﻰ ﻫﺫﻩ ﺍﻟﺩﺍﻟﺔ‪.‬‬
‫ﻓﻲ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺜﺎﻟﺜﺔ ﺘﻨﻅﻴﻑ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻭﻫﻲ‬

‫)(‪txtname.ResetText‬‬
‫‪Dim s As String‬‬ ‫‪ -٥‬ﺤﺫﻑ ﻋﻨﺼﺭ ﻤﻥ‬

‫"ﻫل ﺃﻨﺕ ﻤﺘﺄﻜﺩ ﻤﻥ ﺤﺫﻑ " & ‪s = txtname.Text‬‬
‫ﺍﻟﻘﺎﺌﻤﺔ‪ .‬ﺨﻁﻭﺘﺎﻥ‬
‫‪" ،MessageBox.YesNo‬ﺘﺤﺫﻴﺭ ‪ :‬ﺤﺫﻑ"‪If MessageBox.Show(s،‬‬
‫ﻹﺘﻤﺎﻡ ﻫﺫﻩ ﺍﻟﻌﻤﻠﻴﺔ‪.‬‬
‫_ )‪+ MessageBox.IconQuestion‬‬
‫ﺃﻭﻻ ﺍﻟﺘﺄﻜﺩ ﻤﻥ ﺃﻥ‬
‫=‬ ‫‪DialogResult.Yes Then‬‬
‫ﺍﻟﻤﺴﺘﺨﺩﻡ ﻴﺭﻴﺩ ﺤﺫﻑ‬
‫)‪lstname.Items.Remove(lstname.SelectedIndex‬‬
‫‪End If‬‬ ‫ﺍﻟﻌﻨﺼﺭ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ‪.‬‬
‫ﺜﺎﻨﻴﺎ ‪ :‬ﻋﻤﻠﻴﺔ ﺍﻟﺤﺫﻑ‪.‬‬
‫‪١٠٩‬‬
‫ﻓﻲ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻷﻭﻟﻰ ﻨﻌﺭﻑ ﻤﺘﻐﻴﺭ ﻟﺤﻔﻅ ﺍﻟﺭﺴﺎﻟﺔ ﺍﻟﺘﺤﺫﻴﺭﻴﺔ ﻗﺒل ﺤﺫﻑ‬
‫ﺍﻻﺴﻡ‪.‬‬
‫ﻓﻲ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺜﺎﻨﻴﺔ ﻨﺤﻔﻅ ﺍﻻﺴﻡ ﺍﻟﺤﺎﻟﻲ ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺒﺎﻹﻀﺎﻓﺔ‬
‫ﺇﻟﻰ ﺍﻟﺠﻤﻠﺔ ﺍﻟﺘﺤﺫﻴﺭﻴﺔ‪ .‬ﻤﺜﺎل ﻟﻭ ﺍﺨﺘﺎﺭ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﺍﺴﻡ ﺃﺤﻤﺩ‬
‫ﻓﺈﻨﻪ ﺴﻴﻅﻬﺭ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ‪ .‬ﻓﺈﺫﺍ ﻨﻘﺭ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﺯﺭ ﺤﺫﻑ ﻓﺴﺘﻜﻭﻥ‬
‫ﺍﻟﻌﺒﺎﺭﻩ ﻫل ﺃﻨﺕ ﻤﺘﺄﻜﺩ ﻤﻥ ﺤﺫﻑ ﺃﺤﻤﺩ‪ .‬ﻜﻤﺎ ﺘﻌﺭﻑ ﺃﻥ ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﻴﺔ‬
‫‪ Text‬ﻫﻲ ﻗﻴﻤﺔ ﻨﺼﻴﺔ ﺒﻤﻌﻨﻰ ﺃﻨﻪ ﻨﺹ ﻭﻟﻬﺫﺍ ﺍﻟﺴﺒﺏ ﺍﺴﺘﺨﺩﻤﻨﺎ ﺍﻹﺸﺎﺭﺓ &‬
‫ﻭﻫﻲ ﻹﻀﺎﻓﺔ ﻨﺹ ﺇﻟﻰ ﻨﺹ ‪.‬‬
‫ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺜﺎﻟﺜﺔ ﺴﻭﻑ ﺘﻅﻬﺭ ﻟﻠﻤﺴﺘﺨﺩﻡ ﺭﺴﺎﻟﺔ ﺘﺄﻜﻴﺩﻴﺔ ﻟﻠﺤﺫﻑ ﻓﺈﺫﺍ ﻀﻐﻁ‬
‫ﺯﺭ ‪Yes‬ﻓﺴﻭﻑ ﻴﺘﻡ ﺍﻟﺤﺫﻑ‪.‬‬
‫ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺭﺍﺒﻌﺔ ﺴﺒﻕ ﺘﻭﻀﻴﺤﻬﺎ ﻭﺴﻭﻑ ﺘﻘﻭﻡ ﺒﻌﻤﻠﻴﺔ ﺍﻟﺤﺫﻑ‪.‬‬
‫‪ AcceptButton‬ﻓﻲ ﺍﻟﻨﻤﻭﺫﺝ ﻤﻌﻨﺎﻫﺎ ﺃﻥ ﻫﺫﺍ ﺍﻟﺯﺭ ﺍﻟﺫﻱ ﻫﻭ‬ ‫ﻤﻼﺤﻅﺔ ‪ :‬ﺨﺎﺼﻴﺔ‬

‫‪ cmdAdd‬ﺴﻴﻜﻭﻥ ﻫﻭ ﺍﻟﺯﺭ ﺍﻹﻓﺘﺭﺍﻀﻲ ﺒﻤﻌﻨﻰ ﻋﻨﺩﻤﺎ ﺃﻀﻐﻁ ﺯﺭ ﺍﻟﺭﺠﻭﻉ ﻓﻲ ﻟﻭﺤﺔ‬
‫ﺍﻟﻤﻔﺎﺘﻴﺢ –‪ -Enter‬ﻜﺄﻨﻲ ﻨﻘﺭﺕ ﻫﺫﺍ ﺍﻟﺯﺭ –‪ -cmdAdd‬ﺒﺎﻟﻔﺄﺭﺓ‪ .‬ﻭﻫﺫﺍ ﻴﻔﻴﺩ ﻋﻨﺩﻤﺎ ﻴﻜﻭﻥ‬
‫ﻫﻨﺎﻙ ﺤﺎﺠﺔ ﻟﺴﺭﻋﺔ ﺍﻟﺘﻌﺎﻤل ﻤﺜل ﺃﻥ ﺘﻜﻭﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻜﺜﻴﺭﺓ ﻓﻼ ﺃﺤﺘﺎﺝ ﻜل ﻤﺭﻩ ﺃﻥ ﺃﻨﻘﺭ ﺯﺭ‬
‫ﺍﻹﻀﺎﻓﺔ ﺒﺎﻟﻔﺄﺭﺓ ﻤﻤﺎ ﻴﺴﺒﺏ ﺍﻟﺒﻁﺀ‪ .‬ﻓﻘﻁ ﺍﺠﻌل ﺍﻟﺯﺭ ﺍﻟﺫﻱ ﺘﺭﻴﺩ ﻫﻭ ‪ AcceptButton‬ﻭﻟﻥ‬
‫ﺘﺤﺘﺎﺝ ﻟﻠﻔﺄﺭﺓ‪ .‬ﻓﻲ ﻤﺜﺎﻟﻨﺎ ﻫﺫﺍ ﻓﻘﻁ ﺍﻜﺘﺏ ﺍﻻﺴﻡ ﻭﺍﻀﻐﻁ ﺯﺭ ﺍﻟﺭﺠﻭﻉ ﻭﺴﻭﻑ ﻴﻀﻴﻔﻪ ﻟﻠﻘﺎﺌﻤﺔ‪.‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺤﺴﺏ ﺍﻟﺨﻁﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ -١‬ﺃﻜﺘﺏ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺃﺤﻤﺩ ﺜﻡ ﺍﻨﻘﺭ ﺍﻀﺎﻓﺔ ﺃﻭ ﺍﻀﻐﻁ ﺯﺭ ﺍﻟﺭﺠﻭﻉ‪.‬‬
‫‪-٢‬ﺃﻜﺘﺏ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺨﺎﻟﺩ ﺜﻡ ﺍﻨﻘﺭ ﺍﻀﺎﻓﺔ ﺃﻭ ﺍﻀﻐﻁ ﺯﺭ ﺍﻟﺭﺠﻭﻉ‪.‬‬
‫‪-٣‬ﺃﻜﺘﺏ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻤﺴﺎﻋﺩ ﺜﻡ ﺍﻨﻘﺭ ﺍﻀﺎﻓﺔ ﺃﻭ ﺍﻀﻐﻁ ﺯﺭ ﺍﻟﺭﺠﻭﻉ‪.‬‬
‫‪-٤‬ﺃﻜﺘﺏ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺩﺨﻴل ﺜﻡ ﺍﻨﻘﺭ ﺍﻀﺎﻓﺔ ﺃﻭ ﺍﻀﻐﻁ ﺯﺭ ﺍﻟﺭﺠﻭﻉ‪.‬‬
‫ﺤﺘﻰ ﺍﻵﻥ ﻻﺤﻅ ﺃﻥ ﺍﻻﺴﻤﺎﺀ ﺍﻟﺘﻲ ﻜﺘﺒﺘﻬﺎ ﺍﻀﻴﻔﺕ ﺇﻟﻰ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪.(٩-٩‬‬
‫‪١١٠‬‬
‫‪-٥‬ﺍﺨﺘﺭ ﺃﺤﺩ ﺍﻻﺴﻤﺎﺀ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﻭﻻﺤﻅ ﺃﻨﻪ ﻴﻅﻬﺭ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ‪.‬‬

‫‪-٦‬ﺍﺨﺘﺭ ﺍﺴﻡ ﺜﺎﻨﻲ ﻭﺫﻟﻙ ﺒﺎﻟﻨﻘﺭ ﻋﻠﻴﻪ ﺜﻡ ﻻﺤﻅ ﺃﻥ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻴﺘﻐﻴﺭ‪.‬‬
‫‪-٧‬ﻏﻴﺭ ﻫﺫﺍ ﺍﻻﺴﻡ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺜﻡ ﺍﻨﻘﺭ ﺯﺭ ﺘﻌﺩﻴل ﻭﻻﺤﻅ ﺍﻨﻪ ﻴﺘﻐﻴﺭ ﻓﻲ‬
‫ﺍﻟﻘﺎﺌﻤﺔ‪.‬‬
‫‪-٨‬ﺍﻨﻘﺭ ﺯﺭ ﺤﺫﻑ ﺴﺘﻅﻬﺭ ﻟﻙ ﺍﻟﺭﺴﺎﻟﺔ ﻜﻤﺎ ﻓﻲ ﺸﻜل )‪.(١٠-٩‬‬
‫‪-٩‬ﺍﻨﻘﺭ ﺯﺭ ﺨﺭﻭﺝ ﻷﻨﻬﺎﺀ ﺍﻟﺒﺭﻨﺎﻤﺞ‪.‬‬
‫ﺷﻜﻞ ‪ ١٠-٩‬ﺣﺬﻑ ﺍﺳﻢ ﻣﻦ ﺍﻟﻘﺎﺋﻤﺔ‬ ‫ﺷﻜﻞ ‪ ٩-٩‬ﺍﺿﺎﻓﺔ ﺍﲰﺎﺀ ﺇﱃ ﺍﻟﻘﺎﺋﻤﺔ‬
‫‪١١١‬‬
‫ﺍﻟﺩﺭﺱ ﺍﻟﺭﺍﺒﻊ‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺜﻼﺜﺔ ﺃﻨﻭﺍﻉ ﻤﻥ ﺍﻟﻘﻭﺍﺌﻡ‬

‫ﺒﺭﻨﺎﻤﺞ ﻨﺘﺎﺌﺞ ﺍﻤﺘﺤﺎﻥ ﺍﻟﻁﻼﺏ‬
‫ﺴﻭﻑ ﻨﻘﻭﻡ ﻓﻲ ﺍﻟﺘﺩﺭﻴﺏ ﺍﻟﺘﺎﻟﻲ ﺒﺎﻟﺘﻌﺎﻤل ﻤﻊ ﺜﻼﺜﺔ ﺃﻨﻭﺍﻉ ﻤﻥ ﺍﻟﻘﻭﺍﺌﻡ ﻭﻫﻲ ﻤﺭﺒﻊ‬ ‫ﺍﻟﻬﺩﻑ‬
‫ﺍﻟﻘﺎﺌﻤﺔ ﻭﺍﻷﺩﺍﺓ ﺍﻟﻤﺭﻜﺒﺔ ﻭ ﻗﺎﺌﻤﺔ ﻤﺭﺒﻊ ﺍﻟﺨﻴﺎﺭ‪ .‬ﻭﻫﻲ ﻤﻥ ﺍﻷﺩﻭﺍﺕ ﺍﻟﻤﻬﻤﺔ ﻓﻲ ‪vb.net‬‬
‫ﺨﺼﻭﺼﺎ ﻟﻤﻥ ﻴﺭﻴﺩ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫ﻨﻤﻭﺫﺝ ﻭﺴﻭﻑ ﻨﻀﻴﻑ ﺇﻟﻴﻪ ﻤﺭﺒﻊ ﻗﺎﺌﻤﺔ –‪ -ListBox‬ﻭ ﺃﺩﺍﺓ ﻤﺭﻜﺒﺔ ﻭ ﻗﺎﺌﻤﺔ ﻤﺭﺒﻊ‬ ‫ﺍﻷﺩﻭﺍﺕ‬
‫ﺸﻜل )‪-٩‬‬ ‫ﺍﻟﺨﻴﺎﺭ ﻭ ﺃﺭﺒﻊ ﺃﺯﺭﺍﺭ ﺃﻤﺭ ﻭﺴﺒﻊ ﺃﺩﺍﻭﺍﺕ ﻋﻨﻭﺍﻥ ﻭﺃﺩﺍﺓ ﻨﺹ‪ .‬ﺍﻨﻅﺭ‬
‫‪(١١‬‬
‫ﺴﺘﻜﻭﻥ ﺍﻟﻌﻤﻠﻴﺔ ﻜﺎﻟﺘﺎﻟﻲ ‪ .‬ﺴﻭﻑ ﺘﻜﺘﺏ ﺍﺴﻡ ﻓﻲ ﺃﺩﺍﺓ ﺍﻟﻨﺹ ﺜﻡ ﺘﻨﻘﺭ ﺯﺭ ﺇﻀﺎﻓﺔ ﺃﻭ‬ ‫ﺍﻟﻨﺎﺘﺞ‬
‫ﺘﻀﻐﻁ ﺯﺭ ﺍﻟﺭﺠﻭﻉ – ‪ -Enter‬ﺜﻡ ﺴﻴﻨﺘﻘل ﻤﺎ ﻜﺘﺒﺘﻪ ﻤﻥ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺇﻟﻰ ﺍﻟﻘﺎﺌﻤﺔ‬
‫ﺫﺍﺕ ﺍﻟﻌﻼﻤﺔ ‪ .‬ﻟﺤﺫﻑ ﺃﻱ ﺍﺴﻡ ﺍﺨﺘﺭ ﺍﻹﺴﻡ ﻤﻥ ﺍﻟﻘﺎﺌﻤﺔ ﺜﻡ ﺍﻨﻘﺭ ﻋﻠﻰ ﺯﺭ ﺤﺫﻑ‬
‫ﺴﺘﻅﻬﺭ ﻟﻙ ﺭﺴﺎﻟﺔ ﺘﺄﻜﻴﺩﻴﺔ ﺍﺨﺘﺭ ‪ Yes‬ﻟﻠﺤﺫﻑ ﺃﻭ ‪ No‬ﻹﻟﻐﺎﺀ ﺃﻤﺭ ﺍﻟﺤﺫﻑ‪ .‬ﻋﻨﺩ‬
‫ﺍﻹﻨﺘﻬﺎ ﻤﻥ ﻜﺘﺎﺒﺔ ﺍﻷﺴﻤﺎﺀ ﺍﻨﻘﺭ ﻋﻠﻰ ﺍﺴﻡ ﺍﻟﻁﺎﻟﺏ ﺍﻟﻨﺎﺠﺢ ﻤﺭﺓ ﻭﺍﺤﺩ ﻤﻤﺎ ﻴﺅﺩﻱ ﺇﻟﻰ‬
‫ﺘﻅﻠﻴل ﻫﺫﺍ ﺍﻹﺴﻡ ﺍﻨﻘﺭ ﻋﻠﻰ ﺍﻟﻤﺭﺒﻊ ﺍﻟﺫﻱ ﺒﺠﻭﺍﺭ ﺍﻻﺴﻡ ﻟﻜﻲ ﺘﻅﻬﺭ ﻋﻠﻴﻪ ﻋﻼﻤﺔ ‪. 9‬‬
‫ﻀﻊ ﻫﺫﻩ ﺍﻟﻌﻼﻤﺔ ﺍﻤﺎﻡ ﺍﻟﻁﻼﺏ ﺍﻟﻨﺎﺠﺤﻴﻥ‪ .‬ﻓﻲ ﺍﻟﻨﻬﺎﻴﺔ ﺍﻨﻘﺭ ﺯﺭ ﺘﻭﺯﻴﻊ ﻟﻜﻲ ﻴﻨﻘل‬
‫ﺍﻟﻁﻼﺏ ﺍﻟﻨﺎﺠﺤﻴﻥ ﺇﻟﻰ ﻤﺭﺒﻊ ﺍﻟﻘﺎﺌﻤﺔ ﻭﺍﻟﻁﻼﺏ ﻏﻴﺭ ﺍﻟﻨﺎﺠﺤﻴﻥ ﺇﻟﻰ ﺍﻷﺩﺍﺓ ﺍﻟﻤﺭﻜﺒﺔ‬
‫ﻭﻴﻅﻬﺭ ﻟﻙ ﻋﻠﻰ ﺃﺩﻭﺍﺕ ﺍﻟﻌﻨﻭﺍﻥ ﻋﺩﺩ ﺍﻟﻁﻼﺏ ﺍﻟﻜﻠﻲ ﻭﻋﺩﺩ ﺍﻟﻨﺎﺠﺤﻴﻥ ﻭﻋﺩﺩ‬
‫ﺍﻟﺭﺍﺴﺒﻴﻥ‪ .‬ﻟﻠﺨﺭﻭﺝ ﺍﻨﻘﺭ ﻋﻠﻰ ﺯﺭ ﺨﺭﻭﺝ‪ .‬ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪(١٢-٩‬‬
‫‪١١٢‬‬

‫ﻀﻊ ﺍﻷﺩﻭﺍﺕ ﻜﻤﺎ ﻫﻭ ﻤﻭﻀﺢ ﻓﻲ ﺸﻜل )‪ (١١-٩‬ﻭﺠﺩﻭل ﺍﻟﺨﺼﺎﺌﺹ‬ ‫‪ -١‬ﻭﻀﻊ‬
‫ﺍﻷﺩﺍﻭﺕ ﻋﻠﻰ‬
‫ﺷﻜﻞ ‪ : ١١-٩‬ﺛﻼﺛﺔ ﺃﻧﻮﺍﻉ ﻣﻦ ﺍﻟﻘﻮﺍﺋﻢ‬ ‫ﺍﻟﻨﻤﻭﺫﺝ‬
‫ﻏﻴﺭ ﺨﺼﺎﺌﺹ ﺍﻷﺩﻭﺍﺕ ﻟﺘﺼﺒﺢ ﻤﻁﺎﺒﻘﺔ ﻟﻠﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪(١١-٩‬‬ ‫‪ -٢‬ﺘﻌﺩﻴل‬
‫ﺍﻟﺨﺼﺎﺌﺹ‬
‫ﺍﻟﻤﻁﻠﻭﺒﺔ ﺃﺜﻨﺎﺀ‬
‫ﺍﻟﻘﻴﻤﺔ‬ ‫ﺍﻟﺨﺎﺼﻴﺔ‬ ‫ﺍﺴﻡ ﺍﻷﺩﺍﺓ‬ ‫ﺍﻟﺘﺼﻤﻴﻡ‬
‫‪LblName‬‬ ‫‪Name‬‬ ‫‪Label1‬‬

‫ﺍﻻﺴﻡ‬ ‫‪Text‬‬
‫‪lblSuccess‬‬ ‫‪Name‬‬ ‫‪Label2‬‬
‫ﻋﺩﺩ ﺍﻟﻨﺎﺠﺤﻴﻥ‬ ‫‪Text‬‬
‫‪lblFail‬‬ ‫‪Name‬‬ ‫‪Label3‬‬
‫ﻋﺩﺩ ﺍﻟﺭﺍﺴﺒﻴﻥ‬ ‫‪Text‬‬
‫‪lblAll‬‬ ‫‪Name‬‬ ‫‪Label4‬‬
‫ﻋﺩﺩ ﺍﻟﻁﻼﺏ‬ ‫‪Text‬‬
‫‪Label5‬‬ ‫‪Name‬‬ ‫‪Label5‬‬
‫ﺠﻤﻴﻊ ﺍﻟﻁﻼﺏ‬ ‫‪Text‬‬
‫ﺍﻟﻨﺎﺠﺤﻭﻥ‬ ‫‪Text‬‬
‫ﺍﻟﺭﺍﺴﺒﻭﻥ‬ ‫‪Text‬‬
‫‪txtName‬‬ ‫‪Name‬‬ ‫‪Text1‬‬
‫‪Text‬‬
‫‪cmdAdd‬‬ ‫‪Name‬‬ ‫‪Button1‬‬
‫‪١١٣‬‬
‫ﺍﻀﺎﻓﺔ‬ ‫‪Text‬‬
‫‪cmdUpdate‬‬ ‫‪Name‬‬ ‫‪Button2‬‬
‫ﺤﺫﻑ‬ ‫‪Text‬‬
‫‪CmdMove‬‬ ‫‪Name‬‬ ‫‪Button3‬‬
‫ﺘﻭﺯﻴﻊ‬ ‫‪Text‬‬
‫‪CmdExit‬‬ ‫‪Name‬‬ ‫‪Button4‬‬
‫ﺨﺭﻭﺝ‬ ‫‪Text‬‬
‫‪LstSuccess‬‬ ‫‪Name‬‬ ‫‪ListBox1‬‬
‫‪cboFail‬‬ ‫‪Name‬‬ ‫‪ComboBox1‬‬
‫‪chsAll‬‬ ‫‪Name CheckedListBox‬‬
‫‪Right RightToLeft‬‬ ‫‪Form1‬‬
‫‪cmdAdd AcceptButton‬‬
‫‪Moccasin‬‬ ‫‪BackColor‬‬
‫‪ .I‬ﺍﻨﻘﺭ ﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺯﺭ ﺇﻀﺎﻓﺔ‪ .‬ﻭﺍﻜﺘﺏ ﺍﻟﺘﺎﻟﻲ‬ ‫‪ -٣‬ﺇﻀﺎﻓﺔ‬

‫ﻋﻨﺼﺭ ﺇﻟﻰ‬
‫ﻗﺎﺌﻤﺔ ﻤﺭﺒﻊ‬
‫‪If txtName.Text <> "" Then‬‬ ‫ﺍﻟﺨﻴﺎﺭ‪ .‬ﻭﻴﻘﺎل‬
‫)‪chsAll.Items.Add(txtName.Text‬‬
‫ﻓﻴﻪ ﻤﺜل ﻤﺎ‬
‫)(‪txtName.Focus‬‬
‫ﻗﻴل ﻓﻲ ﺇﻀﺎﻓﺔ‬
‫)(‪txtName.ResetText‬‬ ‫ﻋﻨﺼﺭ ﺇﻟﻰ‬
‫‪Else‬‬ ‫ﺍﻟﻘﺎﺌﻤﺔ‬
‫‪"،‬ﺘﻨﺒﻴﻪ "‪" ،‬ﻴﺠﺏ ﻜﺘﺎﺒﺔ ﺍﺴﻡ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ" (‪MessageBox.Show‬‬
‫)‪MessageBox.OK‬‬
‫‪End If‬‬
‫‪ .II‬ﺒﻌﺩ ﺍﻟﺘﺄﻜﺩ ﻤﻥ ﺃﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺃﺩﺨل ﺍﺴﻤﺎ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ‪ .‬ﻨﺴﺘﺨﺩﻡ ﺍﻟﺩﺍﻟﺔ‬

‫‪ Add‬ﻟﻺﻀﺎﻓﺔ ﻟﻠﻘﺎﺌﻤﺔ‪ .‬ﺒﺎﻟﻁﺒﻊ ﻻﺒﺩ ﺃﻥ ﺘﻌﻁﻲ ﻫﺫﻩ ﺍﻟﺩﺍﻟﺔ ﻤﺎ ﺘﺭﻴﺩ ﺇﻀﺎﻓﺘﻪ‪ .‬ﻓﻲ ﻤﺜﺎﻟﻨﺎ ﻫﺫﺍ‬
‫ﻨﺤﻥ ﻨﺭﻴﺩ ﺇﻀﺎﻓﺔ ﺍﻻﺴﻡ ﺍﻟﺫﻱ ﻴﺩﺨﻠﻪ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻟﺫﻟﻙ ﺃﻋﻁﻴﻨﺎ ﻫﺫﻩ ﺍﻟﺩﺍﻟﺔ‬
‫ﺍﻻﺴﻡ ﺍﻟﺫﻱ ﺃﺩﺨﻠﻪ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻭﻫﻭ ﻤﻭﺠﻭﺩ ﻓﻲ ﺍﻟﺨﺎﺼﻴﺔ ‪Text‬‬
‫)‪chsAll.Items.Add(txtname.Text‬‬
‫‪١١٤‬‬
‫‪ .III‬ﻓﻲ ﺤﺎﻟﺔ ﺃﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻟﻡ ﻴﺩﺨل ﺍﺴﻡ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻟﻥ ﻴﺘﻡ ﺘﻨﻔﻴﺫ ﻤﺎﻴﻨﺩﺭﺝ‬
‫ﺘﺤﺕ ‪ If‬ﻭﺴﻴﻨﻔﺫ ﺒﺩﻻ ﻤﻨﻪ ﻤﺎﺒﻌﺩ ‪ Else‬ﻟﺫﻟﻙ ﺴﻭﻑ ﺘﻅﻬﺭ ﺭﺴﺎﻟﺔ ﻟﻠﻤﺴﺘﺨﺩﻡ ﺘﺨﺒﺭﻩ ﺃﻨﻪ‬
‫ﻴﺠﺏ ﺃﻥ ﻴﻜﺘﺏ ﺍﺴﻡ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ‪.‬‬
‫ﺤﺫﻑ‬ ‫‪-٤‬‬
‫ﻤﻥ‬ ‫ﻋﻨﺼﺭ‬
‫‪ .I‬ﺍﻨﻘﺭ ﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺯﺭ ﺤﺫﻑ ﻭﺍﻜﺘﺏ ﺍﻟﺘﺎﻟﻲ‬ ‫ﺍﻟﻘﺎﺌﻤﺔ‬
‫‪Dim s As String‬‬
‫‪If chsAll.SelectedIndex <>-1 Then‬‬
‫‪" & chsAll.SelectedItem.ToString‬ﻫل ﺃﻨﺕ ﻤﺘﺄﻜﺩ ﻤﻥ ﺤﺫﻑ " = ‪s‬‬
‫‪" ،‬ﺘﺤﺫﻴﺭ ‪ :‬ﺤﺫﻑ"‪If MessageBox.Show(s_ ،‬‬
‫_ )‪MessageBox.YesNo + MessageBox.IconQuestion‬‬
‫=‬ ‫‪DialogResult.Yes Then‬‬
‫)‪chsAll.Items.Remove(chsAll.SelectedIndex‬‬
‫‪End If‬‬
‫‪End If‬‬
‫‪ .II‬ﻨﻌﺭﻑ ﻤﺘﻐﻴﺭ ‪ s‬ﻤﻥ ﻨﻭﻉ ﻨﺹ ﻟﻜﻲ ﻴﺤﻔﻅ ﻨﺹ ﺍﻟﺘﺤﺫﻴﺭ ﻤﻥ ﺍﻟﺤﺫﻑ‬

‫ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺫﻱ ﻴﺭﻴﺩ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺤﺫﻓﻪ‪.‬‬
‫‪ .III‬ﻨﺘﺄﻜﺩ ﻤﻥ ﺃﻥ ﻫﻨﺎﻙ ﺍﺴﻡ ﻤﺨﺘﺎﺭ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﻭﺫﻟﻙ ﺒﺎﻟﺘﺄﻜﺩ ﻤﻥ ﻗﻴﻤﺔ ﺍﻟﺨﺎﺼﻴﺔ‬
‫‪ chsAll.SelectedIndex‬ﻓﺈﺫﺍ ﻜﺎﻨﺕ ﻗﻴﻤﺘﻬﺎ ‪ ١-‬ﻋﺭﻓﻨﺎ ﺃﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻟﻡ‬
‫ﻴﺨﺘﺭ ﺸﻴﺌﺎ‪.‬‬
‫‪ .IV‬ﻴﺘﻡ ﻓﻲ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺩﻤﺞ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺫﻱ ﺍﺨﺘﺎﺭﻩ ﺍﻟﻤﺴﺘﺨﺩﻡ ‪-‬ﺒﻌﺩ ﺘﺤﻭﻴﻠﻪ ﺇﻟﻰ‬
‫ﻨﺹ – ﻤﻊ ﺍﻟﺭﺴﺎﻟﺔ ﺍﻟﺘﺤﺫﻴﺭﻴﺔ ﻜﻤﺎ ﻴﻠﻲ ‪:‬‬
‫‪" & chsAll.SelectedItem.ToString‬ﻫل ﺃﻨﺕ ﻤﺘﺄﻜﺩ ﻤﻥ ﺤﺫﻑ " = ‪s‬‬
‫ﻭﻤﻥ ﺜﻡ ﺍﻅﻬﺎﺭ ﺍﻟﺭﺴﺎﻟﺔ ﻟﻠﻤﺴﺘﺨﺩﻡ‬
‫‪ .V‬ﻴﺘﻡ ﺤﺫﻑ ﺍﻟﻌﻨﺼﺭ ﻤﻥ ﺍﻟﻤﺠﻤﻭﻋﺔ ﻭﺫﻟﻙ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﺩﺍﻟﺔ ‪ Remove‬ﻭﻫﺫﻩ‬
‫ﺍﻟﺩﺍﻟﺔ ﺘﻁﻠﺏ ﺭﻗﻡ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺫﻱ ﻨﺭﻴﺩ ﺤﺫﻓﻪ ﻭﻜﻤﺎ ﺘﺭﻯ ﻓﻘﺩ ﺃﻋﻁﻴﻨﺎﻫﺎ‬
‫‪ chsAll.SelectedIndex‬ﻭﻫﻭ ﺭﻗﻡ ﺍﻟﻌﻨﺼﺭ ﺍﻟﻤﺨﺘﺎﺭ – ﺍﻟﻤﻅﻠل‪.-‬‬
‫‪١١٥‬‬
‫‪ .I‬ﺍﻨﻘﺭ ﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ ﺘﻭﺯﻴﻊ‬ ‫‪ -٥‬ﺘﻭﺯﻴﻊ‬

‫ﺍﻟﻁﻼﺏ ﺇﻟﻰ‬
‫‪Dim i As Integer‬‬
‫‪Dim intSuccess As Integer‬‬ ‫ﻨﺎﺠﺤﻴﻥ‬
‫‪Dim intFail As Integer‬‬ ‫ﻭﺭﺍﺴﺒﻴﻥ‪.‬‬
‫‪Dim intAll As Integer‬‬ ‫ﻓﺎﻟﻤﺭﺒﻊ ﺍﻟﺫﻱ‬
‫)(‪cboFail.Items.Clear‬‬ ‫ﺃﻤﺎﻤﻪ ﻋﻼﻤﺔ‬
‫)(‪lstSuccess.Items.Clear‬‬ ‫‪ X‬ﺴﻭﻑ‬
‫)‪For i = 0 To (chsAll.Items.Count – 1‬‬ ‫ﻴﻜﻭﻥ ﻨﺎﺠﺤﺎ‬
‫‪If chsAll.GetItemChecked(i) = True Then‬‬ ‫ﻭﺴﻴﺫﻫﺏ ﺇﻟﻰ‬
‫))‪lstSuccess.Items.Add(chsall.Items(i‬‬ ‫ﺍﻟﻘﺎﺌﻤﺔ‪.‬‬
‫‪intSuccess = intSuccess + 1‬‬
‫‪intAll = intAll + 1‬‬
‫‪Else‬‬
‫))‪cboFail.Items.Add(chsall.Items(i‬‬
‫‪intFail = intFail + 1‬‬
‫‪intAll = intAll + 1‬‬
‫‪End If‬‬
‫‪Next‬‬
‫‪lblSuccess.Text = lblSuccess.Text & " = " & intSuccess‬‬
‫‪lblFail.Text = lblFail.Text & " = " & intFail‬‬
‫‪lblAll.Text = lblAll.Text & " = " & intAll‬‬
‫‪ .II‬ﻋﺭﻓﻨﺎ ﺃﺭﺒﻌﺔ ﻤﺘﻐﻴﺭﺍﺕ‪ ،‬ﺃﻭل ﻫﺫﻩ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ‪ I‬ﻭ ﺍﻟﻬﺩﻑ ﻤﻨﻪ ﺃﻥ ﻴﻜﻭﻥ ﻋﺩﺍﺩ‬
‫ﻓﻲ ﺍﻟﺘﻜﺭﺍﺭ‪ intFail .‬ﻭ ‪ intSuccess‬ﻭ ‪ intAll‬ﻟﻨﺤﺘﻔﻅ ﺒﻌﺩﺩ ﺍﻟﺭﺍﺴﺒﻴﻥ‬
‫ﻭﺍﻟﻨﺎﺠﺤﻴﻥ ﻭﺍﻟﻌﺩﺩ ﺍﻟﻜﻠﻲ ﻟﻠﻁﻼﺏ‪.‬‬
‫‪ .III‬ﻨﺤﺫﻑ ﺠﻤﻴﻊ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﻘﺎﺌﻤﺔ ﻭﺍﻷﺩﺍﺓ ﺍﻟﻤﺭﻜﺒﺔ ﻭﺫﻟﻙ ﻓﻴﻤﺎ ﻟﻭ‬
‫ﻜﺎﻥ ﻫﻨﺎﻙ ﻋﻨﺎﺼﺭ ﻤﺴﺒﻘﺎ‪ .‬ﻭﻴﻜﻭﻥ ﺤﺫﻑ ﺠﻤﻴﻊ ﺍﻟﻌﻨﺎﺼﺭ ﻋﻥ ﻁﺭﻴﻕ‬
‫ﺍﻟﺨﺎﺼﻴﺔ ‪. clear‬‬
‫‪ .IV‬ﺘﺒﺩﺃ ﻋﻤﻠﻴﺔ ﺍﻟﺘﻜﺭﺍﺭ ﻟﻠﺘﺄﻜﺩ ﻤﻥ ﺤﺎﻟﺔ ﺍﻟﻌﻨﺎﺼﺭ ﻓﻜل ﻋﻨﺼﺭ ﻗﺩ ﻭﻀﻊ ﺍﻤﺎﻡ‬
‫ﻤﺭﺒﻌﻪ ‪ 9‬ﻓﻬﻭ ﻨﺎﺠﺢ ﻭﺍﻟﻌﻨﺼﺭ ﺍﻟﺫﻱ ﺒﺨﻼﻑ ﺫﻟﻙ ﺭﺍﺴﺏ‪ .‬ﻻﺤﻅ ﺃﻥ ﻋﺩﺍﺩ‬
‫ﺍﻟﺘﻜﺭﺍﺭ ﻴﻨﺘﻬﻲ ﺇﻟﻰ ‪ chsAll.Items.Count – 1‬ﻴﻌﻨﻲ ﻟﻭ ﻜﺎﻥ ﺍﻟﻌﺩﺩ ﺍﻟﻜﻠﻲ‬
‫ﻟﻠﻌﻨﺎﺼﺭ ﺴﺘﺔ ﻓﻨﻬﺎﻴﺔ ﺍﻟﺘﻜﺭﺍﺭ ﺨﻤﺴﺔ ﻟﻜﻥ ﻟﻭ ﻻﺤﻅﺕ ﺒﺩﺍﻴﺘﻪ ﻓﻬﻲ ﻤﻥ ﺼﻔﺭ‬
‫ﻤﻌﻨﻰ ﺫﻟﻙ ﺃﻨﻪ ﺴﺘﻜﺭﺭ ﺴﺕ ﻤﺭﺍﺕ‪.‬‬
‫‪ .V‬ﺴﻭﻑ ﻴﻤﻜﻨﻨﺎ ﺍﻟﺘﻜﺭﺍﺭ ﻤﻥ ﺍﻟﻤﺭﻭﺭ ﻋﻠﻰ ﺠﻤﻴﻊ ﺍﻟﻌﻨﺎﺼﺭ ﻋﻨﺼﺭ ﻋﻨﺼﺭ‬
‫ﻟﻠﺘﺄﻜﺩ ﻤﻥ ﻗﻴﻤﺘﻬﺎ‬
‫‪If chsAll.GetItemChecked(i) = True Then‬‬
‫ﻻﺤﻅ ﺃﻥ ﺨﺎﺼﻴﺔ )‪ chsAll.GetItemChecked(i‬ﻫﻲ ﺍﻟﺘﻲ ﺘﺨﺒﺭﻨﺎ ﻫل ﺍﻟﻌﻨﺼﺭ‬
‫ﺃﻤﺎﻤﻪ ‪ 9‬ﺃﻭ ﻻ‪ .‬ﻓﺈﺫﺍ ﻜﺎﻨﺕ ﻗﻴﻤﺔ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ‪ True‬ﻓﻬﺫﺍ ﻴﺩل ﺃﻥ ﺃﻤﺎﻤﻬﺎ ﻋﻼﻤﺔ‪.‬‬
‫‪١١٦‬‬
‫ﻁﺒﻌﺎ ﺘﻼﺤﻅ ﺃﻨﻨﺎ ﻨﻤﺭ ﻋﻠﻰ ﺠﻤﻴﻊ ﺍﻟﻌﻨﺎﺼﺭ ﻷﻥ ﻗﻴﻤﺔ ‪ I‬ﺘﺯﻴﺩ ﻜل ﻤﺭﻩ ﺤﺘﻰ ﻨﺼل‬
‫ﻟﻠﻌﻨﺼﺭ ﺍﻷﺨﻴﺭ‪.‬‬
‫‪ .VI‬ﺘﺘﻡ ﻋﻤﻠﻴﺔ ﺍﻀﺎﻓﺔ ﺍﻟﻌﻨﺎﺼﺭ ﺫﺍﺕ ﺍﻟﻌﻼﻤﺔ ﺇﻟﻰ ﺍﻟﻘﺎﺌﻤﺔ ﻭﺍﻟﺘﻲ ﻟﻴﺱ ﺃﻤﺎﻤﻬﺎ‬
‫ﻋﻼﻤﺔ ﺇﻟﻰ ﺍﻷﺩﺍﺓ ﺍﻟﻤﺭﻜﺒﺔ‪.‬‬
‫ﻜﻤﺎ ﺘﻼﺤﻅ ﺇﻥ ﻜﺎﻥ ﺃﻤﺎﻡ ﺍﻟﻌﻨﺼﺭ ﻋﻼﻤﺔ ﺃﻀﻔﻨﺎ ﻭﺍﺤﺩ ﺇﻟﻰ ﻗﻴﻤﺔ ‪ intSuccess‬ﻭﺇﻥ ﻟﻡ‬
‫ﻴﻜﻥ ﺃﻤﺎﻤﻪ ﻋﻼﻤﺔ ﺃﻀﻔﻨﺎ ﻭﺍﺤﺩ ﺇﻟﻰ ﻗﻴﻤﺔ ‪ intFail‬ﻭﻓﻲ ﻜﻠﺘﺎ ﺍﻟﺤﺎﻟﺘﻴﻥ ﻨﻀﻴﻑ ﻭﺍﺤﺩ ﺇﻟﻰ‬
‫ﻗﻴﻤﺔ ‪ intAll‬ﺜﻡ ﻨﻌﺭﻀﻬﺎ ﻋﻠﻰ ﺃﺩﻭﺍﺕ ﺍﻟﻌﻨﻭﺍﻥ‪.‬‬
‫ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺤﺴﺏ ﺍﻟﺨﻁﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ -١‬ﺃﻜﺘﺏ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺨﺎﻟﺩ ﺜﻡ ﺍﻨﻘﺭ ﺍﻀﺎﻓﺔ ﺃﻭ ﺍﻀﻐﻁ ﺯﺭ ﺍﻟﺭﺠﻭﻉ‪.‬‬
‫‪ -٢‬ﺃﻜﺘﺏ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻤﺤﻤﺩ ﺜﻡ ﺍﻨﻘﺭ ﺍﻀﺎﻓﺔ ﺃﻭ ﺍﻀﻐﻁ ﺯﺭ ﺍﻟﺭﺠﻭﻉ‪.‬‬
‫‪ -٣‬ﺃﻜﺘﺏ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺃﺤﻤﺩ ﺜﻡ ﺍﻨﻘﺭ ﺍﻀﺎﻓﺔ ﺃﻭ ﺍﻀﻐﻁ ﺯﺭ ﺍﻟﺭﺠﻭﻉ‪.‬‬
‫‪ -٤‬ﺃﻜﺘﺏ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻋﺒﺩﺍﻟﺭﺤﻤﻥ ﺜﻡ ﺍﻨﻘﺭ ﺍﻀﺎﻓﺔ ﺃﻭ ﺍﻀﻐﻁ ﺯﺭ ﺍﻟﺭﺠﻭﻉ‪.‬‬
‫‪ -٥‬ﺃﻜﺘﺏ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻋﺒﺩﺍﷲ ﺜﻡ ﺍﻨﻘﺭ ﺍﻀﺎﻓﺔ ﺃﻭ ﺍﻀﻐﻁ ﺯﺭ ﺍﻟﺭﺠﻭﻉ‪.‬‬
‫‪ -٦‬ﺃﻜﺘﺏ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻋﻤﺭﺜﻡ ﺍﻨﻘﺭ ﺍﻀﺎﻓﺔ ﺃﻭ ﺍﻀﻐﻁ ﺯﺭ ﺍﻟﺭﺠﻭﻉ‬
‫ﺤﺘﻰ ﺍﻵﻥ ﻻﺤﻅ ﺃﻥ ﺍﻻﺴﻤﺎﺀ ﺍﻟﺘﻲ ﻜﺘﺒﺘﻬﺎ ﺘﻀﺎﻑ ﺇﻟﻰ ﺍﻟﻘﺎﺌﻤﺔ ﺇﻤﺎ ﺒﻀﻐﻁ ﺯﺭ ﺍﻟﺭﺠﻭﻉ ﺃﻭ‬
‫ﺍﻟﻨﻘﺭ ﻋﻠﻰ ﺍﻀﺎﻓﺔ‬
‫‪ -٧‬ﺍﻨﻘﺭ ﻤﺭﻩ ﻭﺍﺤﺩﻩ ﻋﻠﻰ ﺍﺴﻡ ﻤﺤﻤﺩ ﻭﻻﺤﻅ ﺃﻨﻪ ﺘﻅﻠل‪.‬‬
‫‪ -٨‬ﺍﻨﻘﺭ ﻋﻠﻰ ﺍﻟﻤﺭﺒﻊ ﺍﻟﺫﻱ ﻋﻠﻰ ﻴﻤﻴﻥ ﻤﺤﻤﺩ ﻭﻻﺤﻅ ﻅﻬﻭﺭ ﺍﻟﻌﻼﻤﺔ ‪.9‬‬
‫‪ -٩‬ﻜﺭﺭ ﺍﻟﺨﻁﻭﺘﻴﻥ ﺍﻟﺴﺎﺒﻘﺘﻴﻥ ﺒﺎﻟﻨﺴﺒﺔ ﻟﻌﺒﺩﺍﻟﺭﺤﻤﻥ ﻭﻋﻤﺭ‪.‬‬
‫‪ -١٠‬ﻴﺠﺏ ﺃﻥ ﻴﻅﻬﺭ ﻟﻙ ﺸﻜل )‪. (١٢-٩‬‬
‫‪ -١١‬ﺍﻨﻘﺭ ﺯﺭ ﺨﺭﻭﺝ ﻷﻨﻬﺎﺀ ﺍﻟﺒﺭﻨﺎﻤﺞ‪.‬‬
‫ﺷﻜﻞ ‪ : ١٢-٩‬ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﻘﺎﺋﻢ ﺍﻟﺜﻼﺙ‬
‫‪١١٧‬‬
‫ﺍﻟﺘﻌﺎﻤل ﺒﺸﻜل ﺠﻴﺩ ﻤﻊ ﺍﻟﻨﻤﻭﺫﺝ‬

‫ﻟﻘﺩ ﺤﺼل ﺘﻐﻴﺭ ﻓﻲ ﻁﺭﻴﻘﺔ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻨﻤﻭﺫﺝ ﺒﻴﻥ ﺍﻻﺼﺩﺍﺭ ﺍﻟﺴﺎﺩﺱ ﻭ ﺍﻟﺩﻭﺕ ﻨﺕ‪ .‬ﺴﻭﻑ ﻨﺤﺎﻭل‬
‫ﺃﻥ ﻨﺘﻜﻠﻡ ﻋﻥ ﺃﺒﺭﺯ ﻤﺎﻴﻬﻡ ﺍﻟﻤﺴﺘﻔﻴﺩ ﻋﻨﺩ ﺘﻌﺎﻤﻠﻪ ﻤﻊ ﺍﻟﻨﻤﻭﺫﺝ ﻤﻥ ﺨﻼل ﺃﻤﺜﻠﺔ ﺘﻘﺭﺏ ﺍﻟﻔﻜﺭﺓ‪.‬‬
‫‪ -١‬ﻜﻴﻔﻴﺔ ﻓﺘﺢ ﻨﻤﻭﺫﺝ ‪ :‬ﻗﻡ ﺒﺈﻀﺎﻓﺔ ﻨﻤﻭﺫﺝ ﺇﻟﻰ ﺍﻟﻤﺸﺭﻭﻉ ﻟﻴﻜﻥ ﺍﺴﻤﻪ ‪ Form1‬ﺜﻡ ﺃﻀﻑ ﻨﻤﻭﺫﺝ‬
‫ﺜﺎﻨﻲ ﻭ ﻟﻴﻜﻥ ﺍﺴﻤﻪ ‪ .Form2‬ﺍﺭﺠﻊ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻷﻭل ﻭ ﺃﻀﻑ ﺯﺭ ﺃﻤﺭ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ‪.‬‬
‫ﺍﻨﻘﺭ ﻤﺯﺩﻭﺠﺎ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ ﻟﺘﻨﺘﻘل ﺇﻟﻰ ﺍﻟﻜﻭﺩ ﺍﻟﺨﺎﺹ ﺒﺤﺩﺙ ﺍﻟﻨﻘﺭ ﺍﻟﺨﺎﺹ ﺒﺎﻟﻨﻤﻭﺫﺝ ﻭ‬
‫ﺍﻜﺘﺏ ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫)‪Private Sub Button1_Click(ByVal Sender As Object, ByVal e As EventArgs‬‬

‫‪Handles Button1.Click‬‬
‫)(‪Dim frm2 As New Form2‬‬
‫)(‪frm2.Show‬‬
‫‪End Sub‬‬
‫ﻓﻲ ﺍﻟﻜﻭﺩ ﺍﻟﺴﺎﺒﻕ ﻗﻤﻨﺎ ﺒﻤﺎ ﻴﻠﻲ ‪:‬‬
‫‪ .I‬ﺘﻌﺭﻴﻑ ﻤﺘﻐﻴﺭ ﻤﻥ ﻨﻭﻉ ‪.Form2‬‬
‫‪ .II‬ﻋﺭﺽ ﻨﻤﻭﺫﺝ ‪.Form2‬‬
‫‪ .III‬ﺤﺎﻭل ﺘﺸﻐﻴل ﺍﻟﻤﺜﺎل ﻭ ﺍﻨﻘﺭ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ ﻭﻻﺤﻅ ﺃﻨﻪ ﻴﻔﺘﺢ ﻨﻤﻭﺫﺝ ﻋﻨﺩ ﻜل ﻨﻘﺭﻩ‪..‬‬
‫‪-٢‬ﻤﻨﻊ ﻋﺭﺽ ﺍﻟﻨﻤﻭﺫﺝ ﺃﻜﺜﺭ ﻤﻥ ﻤﺭﻩ ‪ :‬ﻻﺤﻅﺕ ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﺃﻨﻪ ﻜﻠﻤﺎ ﻨﻘﺭﺕ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ‬
‫ﻋﺭﺽ ﻟﻙ ﻨﻔﺱ ﺍﻟﻨﻤﻭﺫﺝ‪ ،‬ﻤﺎﺫﺍ ﻟﻭ ﺃﺭﺩﺕ ﺃﻥ ﻴﺘﻡ ﻋﺭﺽ ﺍﻟﻨﻤﻭﺫﺝ ﻤﺭﻩ ﻭﺍﺤﺩﺓ ﻓﻘﻁ ﻤﻬﻤﺎ ﻨﻘﺭ‬
‫ﺍﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ‪ .‬ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﻟﻙ ﺍﻟﻔﻜﺭﺓ ‪:‬‬
‫‪Private frm2 As Form2‬‬
‫‪Private Sub Button1_Click(ByVal Sender‬‬ ‫‪As‬‬ ‫‪Object,‬‬ ‫‪ByVal‬‬ ‫‪e‬‬ ‫‪As‬‬

‫‪EventArgs) Handles Button1.Click‬‬
‫‪If IsNothing(frm2) = False Then‬‬
‫‪If frm2.IsDisposed = False Then‬‬
‫‪Else‬‬
‫)(‪frm2 = New Form2‬‬
‫‪End If‬‬
‫‪Else‬‬
‫)(‪frm2 = New Form2‬‬
‫‪End If‬‬
‫‪End Sub‬‬
‫ﻓﻲ ﺍﻟﻜﻭﺩ ﺍﻟﺴﺎﺒﻕ ﻗﻤﻨﺎ ﺒﺎﻟﺨﻁﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫‪ -١‬ﻋﺭﻓﻨﺎ ﻤﺘﻐﻴﺭ ﻤﻥ ﻨﻭﻉ ‪ ،Form2‬ﻓﻘﻁ ﺘﻌﺭﻴﻑ ﺒﺩﻭﻥ ﺇﻨﺸﺎﺀ ﻨﺴﺨﺔ ﻤﻨﻪ ‪.Instance‬‬
‫‪ -٢‬ﻗﻤﻨﺎ ﺒﺎﻟﺘﺄﻜﺩ ﻤﻥ ﺃﻥ ﻨﻤﻭﺫﺝ‪ ٢‬ﻏﻴﺭ ﻤﻭﺠﻭﺩ ﺍﻁﻼﻗﺎ ﻤﻥ ﺨﻼل ﻋﺒﺎﺭﺓ ‪.Isnothing‬‬
‫‪ -٣‬ﺜﻡ ﺘﺄﻜﺩﻨﺎ ﻤﻥ ﺃﻨﻪ ﻤﻬﻠﻙ ﻤﻥ ﺨﻼل ﻋﺒﺎﺭﺓ ‪.Isdisposed‬‬
‫‪ -٤‬ﺒﻌﺩ ﺫﻟﻙ ﺇﺫﺍ ﺍﻨﺘﻔﺕ ﺍﻟﺸﺭﻭﻁ ﺍﻟﺴﺎﺒﻘﺔ ﻨﻘﻭﻡ ﺒﻌﺭﻀﻪ‪.‬‬
‫‪ -٣‬ﺇﺭﺴﺎل ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺒﻴﻥ ﺍﻟﻨﻤﺎﺫﺝ‬

‫ﻗﺩ ﺘﺭﻴﺩ ﺃﻥ ﺘﻌﻴﻥ ﻗﻴﻤﺔ ﻟﻤﺘﻐﻴﺭ ﻓﻲ ﻨﻤﻭﺫﺝ ﻭ ﺘﺴﺘﺭﺠﻌﻬﺎ ﻓﻲ ﻨﻤﻭﺫﺝ ﺁﺨﺭ‪ .‬ﻴﻭﺠﺩ ﻋﺩﺓ ﻁﺭﻕ ﻹﺭﺴﺎل‬
‫ﻤﺘﻐﻴﺭ ﺒﻴﻥ ﻨﻤﻭﺫﺠﻴﻥ ﻤﻨﻬﺎ ﺘﻌﺭﻴﻑ ﺍﻟﻤﺘﻐﻴﺭ ﻋﻠﻰ ﺃﻨﻪ ﻤﺘﻐﻴﺭ ﻋﺎﻡ ﻓﻲ ‪ Module‬ﻭﻤﻨﻬﺎ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﺘﺎﻟﻴﺔ‬
‫ﺍﻟﺘﻲ ﺴﻨﻭﻀﺤﻬﺎ ﻤﻥ ﺨﻼل ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫ﻫﺫﺍ ﺍﻟﻜﻭﺩ ﻴﺠﺏ ﺃﻥ ﻴﻜﻭﻥ ﻓﻲ ‪ Form1‬ﻭﻫﻭ ﺘﻌﺭﻴﻑ ﻟﻠﻤﺘﻐﻴﺭ ﻭ ﻴﺠﺏ ﺃﻥ ﻴﻜﻭﻥ ﻋﻠﻰ ﻤﺴﺘﻭﻯ ﺍﻟﻨﻤﻭﺫﺝ‬
‫‪:‬‬
‫‪Public PassingVar As String‬‬
‫ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ ﻴﻜﻭﻥ ﻓﻲ ﻨﻤﻭﺫﺝ ‪ Form2‬ﻹﻋﻁﺎﺀ ﻗﻴﻤﺔ ﻟﻠﻤﺘﻐﻴﺭ ﺍﻟﺫﻱ ﻋﺭﻓﻨﺎﻩ ﻓﻲ ﻨﻤﻭﺫﺝ‪:١‬‬
‫‪Dim myForm As Form1‬‬
‫"هﺬﻩ اﻟﻘﻴﻤﺔ ﰎ ﺗﻌﻴﻴﻨﻬﺎ ﰲ ﳕﻮذج‪myForm.myVar = "٢‬‬
‫‪ -٤‬ﺘﻐﻴﻴﺭ ﻤﻭﻗﻊ ﺍﻟﻨﻤﻭﺫﺝ ﻓﻲ ﺍﻟﺸﺎﺸﺔ‬

‫ﻟﺘﻐﻴﻴﺭ ﻤﻭﻗﻊ ﺍﻟﻨﻤﻭﺫﺝ ﻓﻲ ﺍﻟﺸﺎﺸﺔ ﺍﺴﺘﺨﺩﻡ ﺨﺎﺼﻴﺔ ‪ DesktopLocation‬ﻭﻫﻲ ﺃﺤﺩ ﺨﺼﺎﺌﺹ‬
‫ﺍﻟﻨﻤﻭﺫﺝ‪ .‬ﻓﺈﺫﺍ ﺃﺭﺩﺕ ﻨﻘل ﺍﻟﻨﻤﻭﺫﺝ ﺇﻟﻰ ﺍﻟﺠﺯﺀ ﺍﻟﻌﻠﻭﻱ ﺍﻟﺸﻤﺎﻟﻲ ﻤﻥ ﺍﻟﺸﺎﺸﺔ ﺍﺴﺘﺨﺩﻡ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫)‪Me.DesktopLocation = New Point(0, 0‬‬
‫ﺇﻨﺸﺎﺀ ﺍﻟﻘﻭﺍﺌﻡ‬
‫ﻴﻌﺘﺒﺭ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻘﻭﺍﺌﻡ ﻤﻌﻴﺎﺭﺍ ﺍﺴﺎﺴﻴﺎ ﻓﻲ ﻜﺜﻴﺭ ﻤﻥ ﺍﻷﻨﻅﻤﺔ‪ .‬ﻤﻥ ﺃﻫﻡ ﻓﻭﺍﺌﺩ ﺍﻟﻘﻭﺍﺌﻡ ﻫﻲ ﺘﻨﻅﻴﻡ ﻭ‬
‫ﺘﺴﻬﻴل ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﻭﻅﺎﺌﻑ ﺍﻟﻨﻅﺎﻡ ﺍﻟﻤﺨﺘﻠﻔﺔ‪ .‬ﺘﻭﻓﺭ ﻟﻨﺎ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻁﺭﻴﻘﺔ ﺴﻬﻠﺔ ﺠﺩﺍ ﻹﻨﺸﺎﺀ‬
‫ﺍﻟﻨﻅﺎﻡ‪ .‬ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﺍﻨﺘﻘﻠﺕ ﺍﻟﻘﻭﺍﺌﻡ ﻟﺘﺼﺒﺢ ﺃﺩﺍﺓ ﻤﺜل ﺍﻷﺩﻭﺍﺕ ﺍﻷﺨﺭﻯ ﺘﺴﺘﻁﻴﻊ ﺇﻀﺎﻓﺘﻬﺎ ﻤﻥ‬
‫ﻤﺭﺒﻊ ﺍﻷﺩﻭﺍﺕ ﻋﻥ ﻁﺭﻴﻕ ﺍﻟﺴﺤﺏ ﻭ ﺍﻻﻓﻼﺕ ﻜﻤﺎ ﺘﺭﻯ ﻤﻥ ﺍﻟﺸﻜل )‪.(١-١١‬‬
‫ﺷﻜﻞ ‪ : ١-١١‬أداة اﻟﻘﻮاﺋﻢ‬
‫ﺘﺘﻜﻭﻥ ﺍﻟﻘﺎﺌﻤﺔ ﻤﻥ ﻋﺩﺓ ﻗﻭﺍﺌﻡ ﻓﺭﻋﻴﺔ ﻜل ﻭﺍﺤﺩ ﻤﻥ ﻫﺫﻩ ﺍﻟﻘﻭﺍﺌﻡ ﺍﻟﻔﺭﻋﻴﺔ ﻴﻤﻜﻥ ﺃﻥ ﻴﻨﻔﺫ ﺃﻤﺭﺍ ﻤﺎ ﻤﺜل‬
‫ﺍﺴﺘﺩﻋﺎﺀ ﻨﻤﻭﺫﺝ ﺁﺨﺭ‪ .‬ﺴﻭﻑ ﻨﻘﻭﻡ ﺒﺘﺼﻤﻴﻡ ﻗﺎﺌﻤﺔ ﻜﻤﺎ ﻴﻅﻬﺭ ﻟﻙ ﻤﻥ ﺍﻟﺸﻜل)‪.(٢-١١‬‬
‫ﺷﻜﻞ ‪ : ٢-١١‬ﺗﺼﻤﻴﻢ اﻟﻘﻮاﺋﻢ ﻓﻲ ﺑﻴﺌﺔ اﻟﺪوت ﻧﺖ‬
‫ﻟﺘﺼﻤﻴﻡ ﺍﻟﻘﻭﺍﺌﻡ ﺍﺘﺒﻊ ﺍﻟﺨﻁﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫‪ -١‬ﺃﻀﻑ ﺃﺩﺍﺓ ﺍﻟﻘﻭﺍﺌﻡ ﻭ ﺫﻟﻙ ﺒﺴﺤﺒﻬﺎ ﻭ ﺍﻓﻼﺘﻬﺎ ﻓﻲ ﺍﻟﻨﻤﻭﺫﺝ ﺃﻭ ﺒﺎﻟﻨﻘﺭ ﺍﻟﻤﺯﺩﻭﺝ ﻋﻠﻴﻬﺎ ﻟﻴﻅﻬﺭ ﻟﻙ‬
‫ﺍﻟﺸﻜل )‪(٣-١١‬‬
‫ﺷﻜﻞ ‪ :٣-١١‬ﺑﻌﺪ ﺇﺿﺎﻓﺔ ﺃﺩﺍﺓ ﺍﻟﻘﺎﺋﻢ ﻟﻠﻨﻤﻮﺫﺝ‬
‫‪ -٢‬ﺍﻨﻘﺭ ﺍﻟﻤﺭﺒﻊ ﺍﻟﺼﻐﻴﺭ ﺍﻟﺫﻱ ﻅﻬﺭ ﻟﻙ ﻤﺭﺓ ﻭﺍﺤﺩﺓ ﻭﺍﻜﺘﺏ ﻜﻠﻤﺔ ﻤﻠﻑ ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ‬
‫ﺍﻟﺸﻜل)‪(٤-١١‬‬
‫ﺷﻜﻞ ‪ : ٤-١١‬ﻃﺮﻳﻘﺔ ﺇﺿﺎﻓﺔ ﻗﺎﺋﻤﺔ ﺭﺋﻴﺴﻴﺔ ﺃﻭ ﻓﺮﻋﻴﺔ‬
‫‪ -٣‬ﺴﻭﻑ ﻴﻅﻬﺭ ﻟﻙ ﻤﺭﺒﻌﺎﻥ ﺁﺨﺭﺍﻥ ﺃﺤﺩﻫﻤﺎ ﻋﻠﻰ ﺍﻟﻴﻤﻴﻥ ﻭ ﺍﻵﺨﺭ ﺇﻟﻰ ﺃﺴﻔل‪ .‬ﻴﻤﺜل ﻫﺫﺍ‬
‫ﺍﻟﻤﺭﺒﻌﺎﻥ ﻤﻜﺎﻨﺎﻥ ﻟﻜﺘﺎﺒﺔ ﺍﺴﻡ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻷﺨﺭﻯ‪ .‬ﻗﻡ ﺒﺎﻟﻨﻘﺭ ﻋﻠﻰ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻴﻤﻨﻰ ﻭﺍﻜﺘﺏ ﻤﺴﺎﻋﺩﺓ‬
‫ﻜﻤﺎ ﺘﺭﻯ ﻤﻥ ﺍﻟﺸﻜل)‪.(٥-١١‬‬
‫ﺷﻜﻞ ‪ : ٥-١١‬ﻇﻬﻮﺭ ﻗﺎﺋﻤﺔ ﻓﺮﻋﻴﺔ ﻭ ﺃﺧﺮﻯ ﺭﺋﻴﺴﻴﺔ ﻋﻨﺪ ﺇﺿﺎﻓﺔ ﻗﺎﺋﻤﺔ ﺭﺋﻴﺴﻴﺔ‬
‫‪ -٤‬ﺃﻜﻤل ﺒﻘﻴﺔ ﺍﻟﻘﻭﺍﺌﻡ ﺜﻡ ﻀﻊ ﻗﺎﺌﻤﺔ ﻓﺭﻋﻴﺔ ﻟﻠﻤﺴﺎﻋﺩﺓ ﺘﻅﻬﺭ ﻋﻨﻭﺍﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ‪.‬‬

‫‪ -٥‬ﺍﺫﻫﺏ ﺇﻟﻰ ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻔﺭﻋﻴﺔ ﻟﻘﺎﺌﻤﺔ ﻤﻠﻑ ﻭ ﺍﻨﻘﺭ ﻤﺯﺩﻭﺠﺎ ﻋﻠﻴﻬﺎ ﻟﻜﻲ ﺘﻨﺘﻘل ﺇﻟﻰ ﺍﻟﺤﺩﺙ ﺍﻟﺨﺎﺹ‬
‫ﺒﻨﻘﺭﻫﺎ ﺜﻡ ﺍﻜﺘﺏ ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫)(‪Dim frm2 As New Form2‬‬
‫ﻻﺤﻅ ﺃﻥ ﻫﺫﺍ ﺍﻟﻜﻭﺩ ﻴﻔﺘﺭﺽ ﺃﻥ ﻫﻨﺎﻙ ﻨﻤﻭﺫﺠﺎ ﺁﺨﺭ ﺍﺴﻤﻪ ‪ . Form2‬ﺸﻐل ﺍﻟﻨﻅﺎﻡ ﺜﻡ ﺍﺨﺘﺭ‬
‫ﺍﻟﻘﺎﺌﻤﺔ ﺍﻟﻔﺭﻋﻴﺔ ﻓﺘﺢ ﻨﻤﻭﺫﺝ‪ ٢‬ﺜﻡ ﺍﻨﻘﺭ ﻋﻠﻴﻬﺎ ﻟﻴﺘﻡ ﻓﺘﺢ ﻫﺫﺍ ﺍﻟﻨﻤﻭﺫﺝ‪.‬‬
‫أداة اﻟﺘﻮﻗﻴﺖ ‪Timer‬‬

‫ﺘﺴﺘﺨﺩﻡ ﺃﺩﺍﺓ ﺍﻟﺘﻭﻗﻴﺕ ﻟﺘﻨﻔﻴﺫ ﻋﻤل ﻤﺎ ﻜل ﻓﺘﺭﺓ ﺯﻤﻨﻴﺔ ﺃﻭ ﻋﻨﺩ ﻭﻗﺕ ﻤﻌﻴﻥ‪ .‬ﻓﺈﺫﺍ ﺃﺭﺩﺕ ﻤﺜﻼ ﺃﻥ‬
‫ﺘﻌﻤل ﻨﺴﺦ ﺍﺤﺘﻴﺎﻁﻲ ﻟﻠﻤﻠﻔﺎﺕ ﻜل ﻴﻭﻡ ﻓﺈﻥ ﺃﺩﺍﺓ ﺍﻟﺘﻭﻗﻴﺕ ﺴﺘﻜﻭﻥ ﺨﻴﺎﺭ ﺠﻴﺩ‪ .‬ﺃﻫﻡ ﺨﺼﺎﺌﺹ ﻫﺫﻩ‬
‫ﺍﻷﺩﺍﺓ ﻫﻲ ﺨﺎﺼﻴﺔ ‪ Interval‬ﻭ ﺘﻤﺜل ﺍﻟﻔﺘﺭﺓ ﺒﺎﻟﻤﻠﻲ ﺜﺎﻨﻴﺔ )‪ (Millisecond‬ﻟﺩﻗﺎﺕ ﺍﻟﻭﻗﺕ‪ .‬ﻗﻡ‬
‫ﺒﻜﺘﺎﺒﺔ ﺍﻟﻜﻭﺩ ﺍﻟﺫﻱ ﺘﺭﻴﺩ ﺘﻨﻔﻴﺫﻩ ﻜل ﻓﺘﺭﺓ ﻤﻥ ﺍﻟﺯﻤﻥ ﺩﺍﺨل ﺍﻟﺤﺩﺙ )(‪ Tick‬ﻭ ﻫﻭ ﺃﻫﻡ ﺃﺤﺩﺍﺙ ﻫﺫﻩ‬
‫ﺍﻷﺩﺍﺓ‪ .‬ﻟﺒﺩﺀ ﺍﻟﻤﺅﻗﺕ ﺍﺴﺘﺨﺩﻡ ﺍﻟﻁﺭﻴﻘﺔ ‪ Start‬ﻭﻫﻲ ﺃﺤﺩ ﻁﺭﻕ ﺃﺩﺍﺓ ﺍﻟﺘﻭﻗﻴﺕ‪ ،‬ﺃﻤﺎ ﺇﺫﺍ ﺃﺭﺩﺕ ﺇﻴﻘﺎﻑ‬
‫ﻫﺫﻩ ﺍﻷﺩﺍﺓ ﻓﺎﺴﺘﺨﺩﻡ ﺍﻟﻁﺭﻴﻘﺔ ‪.Stop‬‬
‫ﺒﺭﻨﺎﻤﺞ ﺍﻟﺴﺎﻋﺔ‬
‫ﻓﻲ ﻫﺫﺍ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺴﻭﻑ ﻨﻘﻭﻡ ﺒﺒﻨﺎﺀ ﺒﺭﻨﺎﻤﺞ ﻴﻤﺜل ﺴﺎﻋﺔ‪ .‬ﺴﻭﻑ ﻴﻜﻭﻥ ﻟﺩﻴﻨﺎ ﺯﺭ ﺃﻤﺭ ﻭ‬
‫ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ ﻭ ﺃﺩﺍﺓ ﺘﻭﻗﻴﺕ‪ ،‬ﻋﻨﺩ ﺍﻟﻨﻘﺭ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ ﺴﻭﻑ ﻴﺘﻡ ﺘﺸﻐﻴل ﺃﺩﺍﺓ ﺍﻟﺘﻭﻗﻴﺕ ﻭ ﺍﻟﺘﻲ‬
‫ﺴﺘﻘﻭﻡ ﺒﻌﺭﺽ ﺍﻟﺴﺎﻋﺔ ﻋﻠﻰ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ‪ .‬ﺃﻀﻑ ﺍﻷﺩﻭﺍﺕ ﺍﻟﺘﻲ ﺘﻅﻬﺭ ﻓﻲ ﺍﻟﺸﻜل )‪(٦-١١‬‬
‫ﺷﻜﻞ ‪ : ٦-١١‬ﺗﺼﻤﻴﻢ ﺑﺮﻧﺎﻣﺞ ﺍﻟﺴﺎﻋﺔ‬
‫‪ -١‬أﻋﻂ اﻷدوات اﻟﺨﺼﺎﺋﺺ اﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫‪cmdStartStop‬‬ ‫‪Name‬‬ ‫‪Button1‬‬
‫ﺘﺸﻐﻴل ﺍﻟﺴﺎﻋﺔ‬ ‫‪Text‬‬
‫‪lblClock‬‬ ‫‪Name‬‬ ‫‪Label1‬‬
‫‪Text‬‬
‫‪Timer1‬‬ ‫‪Name‬‬ ‫‪Timer‬‬
‫‪1000‬‬ ‫‪Interval‬‬ ‫‪Timer‬‬
‫ﺑﺮﻧﺎﻣﺞ اﻟﺴﺎﻋﺔ‬ ‫‪Text‬‬ ‫‪Form‬‬
‫ﻻﺤﻅ ﺃﻥ ﻗﻴﻤﺔ ﺨﺎﺼﻴﺔ ‪ Interval‬ﻫﻲ ‪ ١٠٠٠‬ﻤﻠﻲ ﺜﺎﻨﻴﺔ ﻭ ﻴﺴﺎﻭﻱ ﺜﺎﻨﻴﺔ ﻭﺍﺤﺩﺓ ﻭﻫﻭ ﻤﺎ‬
‫ﻴﻌﻨﻲ ﺃﻥ ﺍﻟﻜﻭﺩ ﺩﺍﺨل ﺍﻟﺤﺩﺙ ‪ Tick‬ﺴﻴﺘﻡ ﺘﻨﻔﻴﺫﻩ ﻜل ﺜﺎﻨﻴﺔ‪.‬‬
‫‪ -٢‬ﻗﻡ ﺒﺎﻟﻨﻘﺭ ﺍﻟﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ ﻭ ﺃﻀﻑ ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ ‪:‬‬

‫‪If Not Timer1.Enabled Then‬‬
‫)(‪Timer1.Start‬‬
‫"ﺍﻟﺴﺎﻋﺔ ﺇﻴﻘﺎﻑ" = ‪Button1.Text‬‬
‫‪Else‬‬
‫)(‪Timer1.Stop‬‬
‫"ﺍﻟﺴﺎﻋﺔ ﺘﺸﻐﻴل" = ‪Button1.Text‬‬
‫‪End If‬‬
‫ﻴﻘﻭﻡ ﻫﺫﺍ ﺍﻟﻜﻭﺩ ﺒﺘﺸﻐﻴل ﺃﻭ ﺇﻴﻘﺎﻑ ﺃﺩﺍﺓ ﺍﻟﺘﻭﻗﻴﺕ‪ ،‬ﻻﺤﻅ ﺃﻨﻪ ﻴﻘﻭﻡ ﺒﺎﻟﺘﺄﻜﺩ ﻤﻥ ﺘﺸﻐﻴل ﺃﺩﺍﺓ ﺍﻟﺘﻭﻗﻴﺕ‬
‫‪ Start‬ﻟﻠﺘﺸﻐﻴل ﻭ ‪Stop‬‬ ‫ﺃﻭ ﺇﻴﻘﺎﻓﻬﺎ ﻤﻥ ﺨﻼل ﺍﻟﺨﺎﺼﻴﺔ ‪ Enabled‬ﺜﻡ ﻴﺴﺘﺨﺩﻡ ﺍﻟﻁﺭﻴﻘﺔ‬
‫ﻟﻺﻴﻘﺎﻑ‪.‬‬
‫‪-٣‬ﺍﺭﺠﻊ ﺇﻟﻰ ﺸﺎﺸﺔ ﻤﺼﻤﻡ ﺍﻟﻨﻤﺎﺫﺝ ﺜﻡ ﺍﻨﻘﺭ ﻤﺯﺩﻭﺠﺎ ﻋﻠﻰ ﺃﺩﺍﺓ ﺍﻟﺘﻭﻗﻴﺕ‪ ،‬ﺴﻭﻑ ﺘﻨﺘﻘل ﺇﻟﻰ ﺍﻟﺤﺩﺙ‬
‫‪ Tick‬ﻭﻫﻭ ﺃﺤﺩ ﺃﺤﺩﺍﺙ ﻫﺫﻩ ﺍﻷﺩﺍﺓ‪ .‬ﺍﻜﺘﺏ ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫‪ = " & TimeString‬اﻟﺴﺎﻋﺔ" = ‪Label1.Text‬‬
‫ﻓﻲ ﻫﺫﺍ ﺍﻟﻜﻭﺩ ﻨﻘﻭﻡ ﺒﻌﺭﺽ ﺍﻟﻭﻗﺕ ﺍﻟﺤﺎﻟﻲ ﻋﻠﻰ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ‪ ،‬ﻭ ﻨﻅﺭﺍ ﻷﻥ ﺍﻟﺤﺩﺙ ‪ Tick‬ﻴﺘﻡ‬
‫ﺘﻨﻔﻴﺫﻩ ﻜل ﺜﺎﻨﻴﺔ ﻓﺈﻨﻪ ﺴﻭﻑ ﻴﺘﻡ ﻋﺭﺽ ﺍﻟﺴﺎﻋﺔ ﻋﻠﻰ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ﻜل ﺜﺎﻨﻴﺔ ﻤﻤﺎ ﻴﻌﻨﻲ ﺃﻨﻙ ﺴﻭﻑ‬
‫ﺘﺸﺎﻫﺩ ﺴﺎﻋﺔ ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل)‪(٧-١١‬‬
‫ﺷﻜﻞ ‪ : ٧-١١‬ﺗﻨﻔﻴﺬ ﺑﺮﻧﺎﻣﺞ ﺍﻟﺴﺎﻋﺔ‬
‫ﺃﺩﺍﺓ ﺍﻟﻭﻗﺕ ﻭ ﺍﻟﺘﺎﺭﻴﺦ ‪DateTimePicker‬‬

‫ﺗﺴﺘﺨﺪم هﺬﻩ اﻷداة ﻟﻌﺮض اﻟﻮﻗﺖ ﺑﺸﻜﻞ ﺟﻤﻴﻞ ﻋﻠﻰ ﺷﻜﻞ ﺗﻘﻮﻳﻢ آﻤﺎ ﺗﻘﻮم ﺑﺤﻔﻆ اﻟﺘﺎرﻳﺦ اﻟﺬي ﺗﻢ‬
‫اﺧﺘﻴﺎرﻩ ﻣﻦ ﻗﺒﻞ اﻟﻤﺴﺘﺨﺪم‪ .‬أهﻢ ﺧﺼﺎﺋﺺ هﺬﻩ اﻷداة هﻲ ‪:‬‬
‫اﻟﺸﺮح‬ ‫اﻟﺨﺎﺻﻴﺔ‬
‫أﻗﻞ ﻗﻴﻤﺔ ﻳﻤﻜﻦ اﺧﺘﻴﺎرهﺎ ﻣﻦ اﻟﺘﻘﻮﻳﻢ‪.‬‬ ‫‪MinDate‬‬
‫أآﺒﺮ ﻗﻴﻤﺔ ﻳﻤﻜﻦ اﺧﺘﻴﺎرهﺎ ﻣﻦ اﻟﺘﻘﻮﻳﻢ‪.‬‬ ‫‪MaxDate‬‬
‫إذا أردت ﻋﺮض ﻣﺮﺑﻊ اﺧﺘﻴﺎر ﻓﻲ اﻷداة‪.‬‬ ‫‪ShowCheckBox‬‬
‫اﻟﺘﺎرﻳﺦ اﻟﺬي ﺗﻢ اﺧﺘﻴﺎر‪.‬‬ ‫‪Value‬‬
‫ﺃﻀﻑ ﺯﺭ ﺃﻤﺭ ﻭ ﺃﺩﺍﺓ ﺍﻟﻭﻗﺕ ﻭ ﺍﻟﺘﺎﺭﻴﺦ‪ .‬ﺃﻨﻘﺭ ﻤﺯﺩﻭﺠﺎ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ ﺜﻡ ﺍﻜﺘﺏ‬
‫ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫)‪DateTimePicker1.MinDate = New DateTime(1985, 6, 20‬‬
‫‪DateTimePicker1.MaxDate = DateTime.Today‬‬
‫‪DateTimePicker1.ShowCheckBox = True‬‬
‫)‪MessageBox.Show(DateTimePicker1.Value‬‬
‫ﻻﺤﻅ ﺃﻨﻨﺎ ﻋﻴﻨﺎ ﻗﻴﻤﺔ ﺩﻨﻴﺎ ﻭ ﻋﻠﻴﺎ ﻷﺩﺍﺓ ﺍﻟﻭﻗﺕ ﻭ ﺍﻟﺘﺎﺭﻴﺦ ﻓﻠﻭ ﺤﺎﻭﻟﺕ ﺍﺨﺘﻴﺎﺭ ﺃﻱ ﺘﺎﺭﻴﺦ ﻴﺘﺠﺎﻭﺯ‬
‫ﻫﺎﺘﻴﻥ ﺍﻟﻘﻴﻤﺘﻴﻥ ﻓﻠﻥ ﺘﺴﻤﺢ ﻟﻙ ﺍﻷﺩﺍﺓ ﺍﻨﻅﺭ ﺸﻜل )‪.(٨-١١‬‬
‫ﺷﻜﻞ ‪ : ٨-١١‬أداة اﻟﻮﻗﺖ و اﻟﺘﺎرﻳﺦ‬

‫ﺃﺩﻭﺍﺕ ﺍﻟﺤﻭﺍﺭ ﺍﻟﻌﺎﻤﺔ‬

‫ﺘﻘﺩﻡ ﻟﻨﺎ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﺴﺕ ﺃﺩﻭﺍﺕ ﻟﻠﺤﻭﺍﺭ ﺍﻟﻌﺎﻡ ﻭﻫﻲ ‪:‬‬
‫‪ -١‬ﺃﺩﺍﺓ ﺍﻟﺤﻭﺍﺭ ﻟﻔﺘﺢ ﺍﻟﻤﻠﻔﺎﺕ‪.‬‬
‫‪ -٢‬ﺃﺩﺍﺓ ﺍﻟﺤﻭﺍﺭ ﻟﺘﻐﻴﻴﺭ ﺍﻟﺨﻁ‪.‬‬
‫‪ -٣‬ﺃﺩﺍﺓ ﺍﻟﺤﻭﺍﺭ ﻟﺘﻐﻴﻴﺭ ﺍﻟﻠﻭﻥ‪.‬‬
‫‪ -٤‬ﺃﺩﺍﺓ ﺍﻟﺤﻭﺍﺭ ﻟﺤﻔﻅ ﺍﻟﻤﻠﻔﺎﺕ‪.‬‬
‫‪ -٥‬ﺃﺩﺍﺓ ﺍﻟﺤﻭﺍﺭ ﻹﻋﺩﺍﺩ ﺍﻟﺼﻔﺤﺔ‪.‬‬
‫‪ -٦‬ﺃﺩﺍﺓ ﺍﻟﺤﻭﺍﺭ ﻟﻠﻁﺒﺎﻋﺔ‪.‬‬
‫ﺘﺘﺸﺎﺒﻪ ﺒﻌﺽ ﻫﺫﻩ ﺍﻷﺩﻭﺍﺕ ﻓﻴﻤﺎ ﺒﻴﻨﻬﺎ ﺒﻁﺭﻴﻘﺔ ﺍﻟﺘﻌﺎﻤل ﻤﻌﻬﺎ ﻓﺒﻤﺠﺭﺩ ﺃﻥ ﺘﺘﻌﺎﻤل ﻤﻊ ﻭﺍﺤﺩﺓ ﻤﻥ ﻫﺫﻩ‬
‫ﺍﻷﺩﻭﺍﺕ ﺤﺘﻰ ﻴﺼﺒﺢ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺒﺎﻗﻲ ﺍﻷﺩﻭﺍﺕ ﻤﺠﺭﺩ ﻭﻗﺕ‪ .‬ﺴﻭﻑ ﻨﺘﻌﺭﺽ ﻷﻭل ﺜﻼﺙ ﺃﺩﻭﺍﺕ‬
‫ﻭﻨﺘﺭﻙ ﺍﻟﺜﻼﺙ ﺍﻟﺒﺎﻗﻴﺔ ﻟﻙ‪.‬‬
‫ﺃﺩﺍﺓ ﺍﻟﺤﻭﺍﺭ ﻟﻔﺘﺢ ﺍﻟﻤﻠﻔﺎﺕ‬

‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻷﺩﺍﺓ ﺒﻌﺭﺽ ﻤﺭﺒﻊ ﺍﻟﺤﻭﺍﺭ ﺍﻟﺨﺎﺹ ﺒﻔﺘﺢ ﺍﻟﻤﻠﻔﺎﺕ ﻜﻤﺎ ﺘﺤﻭﻱ ﻫﺫﻩ ﺍﻷﺩﺍﺓ ﻋﻠﻰ ﻤﺠﻤﻭﻋﺔ ﻤﻥ‬
‫ﺍﻟﺨﺼﺎﺌﺹ ﻭ ﺍﻟﻁﺭﻕ ﺠﻌﻠﺕ ﺍﻟﺘﻌﺎﻤل ﻤﻌﻬﺎ ﺴﻬﻼ‪ ،‬ﻴﺫﻜﺭ ﺃﻨﻪ ﺤﺼل ﺘﻁﻭﺭ ﻜﺒﻴﺭ ﺒﻴﻥ ﻫﺫﻩ ﺍﻷﺩﺍﺓ ﻓﻲ‬
‫ﺍﻻﺼﺩﺍﺭ ﺍﻟﺴﺎﺩﺱ ﻭ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‪.‬‬
‫ﻓﻲ ﻫﺫﺍ ﺍﻟﻤﺜﺎل ﻗﻡ ﺒﺈﻀﺎﻓﺔ ﺃﺩﺍﺓ ﺍﻟﺤﻭﺍﺭ ﻟﻔﺘﺢ ﺍﻟﻤﻠﻔﺎﺕ ﻭ ﺃﺩﺍﺓ ﺼﻭﺭﺓ ‪ Picturebox‬ﻜﻤﺎ‬
‫ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪cmdOpenPicture‬‬ ‫‪Name‬‬ ‫‪Button1‬‬
‫ﻓﺘﺢ ﺼﻭﺭﺓ‬ ‫‪Text‬‬
‫‪pb‬‬ ‫‪Name‬‬ ‫‪Picturebox‬‬
‫‪ofd‬‬ ‫‪Name OpenFileDialog‬‬
‫ﺍﻨﻘﺭ ﻤﺯﺩﻭﺠﺎ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ ﺜﻡ ﺃﻀﻑ ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ ‪:‬‬

‫‪With ofd‬‬
‫‪.CheckFileExists = True‬‬
‫‪.ShowReadOnly = False‬‬
‫"‪.Filter = "All Files|*.*|Bitmap Files (*)|*.bmp;*.jpg‬‬
‫‪.FilterIndex = 1‬‬
‫‪If .ShowDialog = DialogResult.OK Then‬‬
‫)‪pb.Image = Image.FromFile(.FileName‬‬
‫‪End If‬‬
‫‪End With‬‬
‫ﻓﻲ ﺍﻟﻜﻭﺩ ﺍﻟﺴﺎﺒﻕ ﻗﻤﻨﺎ ﺒﺎﻟﺨﻁﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ -١‬ﺍﺴﺘﺨﺩﻡ ﻋﺒﺎﺭﺓ ‪ With‬ﺤﺘﻰ ﻻﻨﻌﻴﺩ ﻜﺘﺎﺒﺔ ﺍﺴﻡ ﺃﺩﺍﺓ ﺍﻟﺤﻭﺍﺭ ﻜل ﻤﺭﺓ‪.‬‬
‫‪ -٢‬ﺍﺴﺘﺨﺩﻤﻨﺎ ﺨﺎﺼﻴﺔ ﺍﻟﺘﺄﻜﺩ ﻤﻥ ﻭﺠﻭﺩ ﺍﻟﻤﻠﻑ ﻗﺒل ﻓﺘﺤﻪ ‪.‬‬
‫‪ -٣‬ﻤﻨﻌﻨﺎ ﺇﻅﻬﺎﺭ ﺍﻟﻤﻠﻔﺎﺕ ﺍﻟﺘﻲ ﻟﻠﻘﺭﺍﺀﺓ‪.‬‬
‫‪ -٤‬ﺤﺩﺩﻨﺎ ﺃﻨﻭﺍﻉ ﺍﻟﻤﻠﻔﺎﺕ ﺍﻟﺘﻲ ﺴﺘﻅﻬﺭ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﺤﻭﺍﺭ ﻭﻫﻲ ﺍﻟﻤﻠﻔﺎﺕ ﺍﻟﺘﻲ ﻤﻥ ﻨﻭﻉ ‪ Bmp‬ﻭ‬
‫‪ Jpg‬ﻭﻜل ﺍﻟﻤﻠﻔﺎﺕ ﻓﻲ ﺤﺎﻟﺔ ﺍﺨﺘﻴﺎﺭ ‪.All Files‬‬
‫‪ -٥‬ﺇﺫﺍ ﺍﺨﺘﺎﺭ ﺍﻟﻤﺴﺘﻔﻴﺩ ‪ Ok‬ﻤﻥ ﻤﺭﺒﻊ ﺍﻟﺤﻭﺍﺭ ﺴﻭﻑ ﻨﻘﻭﻡ ﺒﻌﺭﺽ ﺍﻟﺼﻭﺭﺓ ﺍﻟﺘﻲ ﺍﺨﺘﺎﺭﻫﺎ ﻋﻠﻰ‬
‫ﺃﺩﺍﺓ ﺍﻟﺼﻭﺭﺓ‪.‬‬
‫ﺍﻨﻅﺭ ﺍﻟﺸﻜل)‪ (٩-١١‬ﺒﻌﺩ ﺍﻟﺘﺸﻐﻴل ﻭ ﺍﻟﻨﻘﺭ ﻋﻠﻰ ﺯﺭ ﻓﺘﺢ ﺍﻟﺼﻭﺭﺓ‬
‫ﺘﺘﻡ ﻋﻤﻠﻴﺔ ﺘﺭﺸﻴﺢ ﻨﻭﻉ ﺍﻟﻤﻠﻔﺎﺕ ﺍﻟﺘﻲ ﺘﺭﻴﺩ ﻓﻲ ‪ File Of Type‬ﻟﻤﺭﺒﻊ ﺍﻟﺤﻭﺍﺭ ﺒﺎﻟﻁﺭﻴﻘﺔ‬
‫ﺍﻟﺘﺎﻟﻴﺔ‪ :‬ﺍﻻﺴﻡ ﺍﻟﺫﻱ ﺘﺭﻴﺩ ﺃﻥ ﻴﻅﻬﺭ ﻭﻫﻭ ﻓﻲ ﺤﺎﻟﺘﻨﺎ ‪ File Name‬ﺜﻡ ﻋﻼﻤﺔ | ﺜﻡ * ﺜﻡ ‪ .‬ﺜﻡ ﻨﻭﻉ‬
‫ﺍﻟﻤﻠﻑ ﻤﺜل ‪ Bmp‬ﺜﻡ ﺘﺒﺩﺃ ﺘﺭﺸﻴﺢ ﺁﺨﺭ ﺒﻨﻔﺱ ﺍﻟﻁﺭﻴﻘﺔ‪.‬‬
‫ﺷﻜﻞ ‪ : ٩-١١‬ﺍﺧﺘﻴﺎﺭ ﻣﻠﻒ ﻣﻦ ﻧﺎﻓﺬﺓ ﺍﳊﻮﺍﺭ‬
‫ﺃﺩﺍﺓ ﺍﻟﺤﻭﺍﺭ ﻟﺘﻐﻴﻴﺭ ﺍﻟﺨﻁ‬

‫ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻷﺩﺍﺓ ﻟﺘﻐﻴﻴﺭ ﺍﻟﺨﻁ ﺍﻟﻤﻜﺘﻭﺏ ﻋﻠﻰ ﺃﺩﺍﺓ ﻤﺎ‪ ،‬ﻓﺈﺫﺍ ﺃﺭﺩﺕ ﺘﻐﻴﻴﺭ ﺍﻟﺨﻁ ﺍﻟﻤﻭﺠﻭﺩ ﻋﻠﻰ‬
‫ﻤﺭﺒﻊ ﻨﺹ ﺃﻭ ﺯﺭ ﺃﻤﺭ ﻓﺎﺴﺘﻌﻤل ﻫﺫﻩ ﺍﻷﺩﺍﺓ ﻟﺘﻐﻴﻴﺭ ﺍﻟﺨﻁ ﻭﺫﻟﻙ ﺒﺘﻌﻴﻴﻥ ﺨﺎﺼﻴﺔ ﺍﻟﺨﻁ ﻓﻲ ﺍﻷﺩﺍﺓ‬
‫ﺍﻟﺘﻲ ﺘﺭﻴﺩ ﺃﻥ ﺘﻐﻴﻴﺭ ﺨﻁﻬﺎ ﺇﻟﻰ ﺍﻟﺨﻁ ﺍﻟﺫﻱ ﺘﻡ ﺍﺨﺘﻴﺎﺭﻩ ﻓﻲ ﺃﺩﺍﺓ ﺤﻭﺍﺭ ﺍﻟﺨﻁ‪ .‬ﺃﻨﺕ ﺨﺒﻴﺭ ﺒﺄﻨﻙ‬
‫ﻋﻨﺩﻤﺎ ﺘﻐﻴﺭ ﺨﻁ ﺍﻟﻨﻤﻭﺫﺝ ﻓﺈﻥ ﺫﻟﻙ ﻴﺅﺩﻱ ﺇﻟﻰ ﺘﻐﻴﻴﺭ ﺨﻁ ﻜل ﺍﻷﺩﻭﺍﺕ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﻨﻤﻭﺫﺝ‪.‬‬
‫ﻗﻡ ﺒﺈﻀﺎﻓﺔ ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ ﻭ ﺯﺭ ﺃﻤﺭ ﻭ ﺃﺩﺍﺓ ﺤﻭﺍﺭ ﺍﻟﺨﻁ ﺜﻡ ﺍﻨﻘﺭ ﻤﺯﺩﻭﺠﺎ ﻋﻠﻰ ﻤﺭﺒﻊ‬
‫ﺍﻟﻨﺹ ﻭ ﺍﻜﺘﺏ ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫‪With FontDialog1‬‬
‫‪.ShowApply = True‬‬
‫‪Button1.Font = .Font‬‬
‫‪Label1.Font = .Font‬‬
‫‪End If‬‬
‫‪ -١‬ﺘﻔﻌﻴل ﺨﺎﺼﻴﺔ ‪ ShowApply‬ﻤﻤﺎ ﻴﺅﺩﻱ ﺇﻟﻰ ﺇﻅﻬﺎﺭ ‪ Apply‬ﻓﻲ ﻤﺭﺒﻊ ﺤﻭﺍﺭ ﺍﻟﺨﻁ‪.‬‬
‫‪ -٢‬ﺍﻟﺘﺄﻜﺩ ﺃﻥ ﺍﻟﻤﺴﺘﻔﻴﺩ ﻨﻘﺭ ﺯﺭ ‪.Ok‬‬
‫‪ -٣‬ﺘﻐﻴﻴﺭ ﺨﻁ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ﻭ ﺯﺭ ﺍﻷﻤﺭ ﺒﺎﻟﺨﻁ ﺍﻟﺫﻱ ﺍﺨﺘﺎﺭﻩ ﺍﻟﻤﺴﺘﻔﻴﺩ‬
‫ﺷﻜﻞ‪ : ١٠-١١‬ﺍﺧﺘﻴﺎﺭ ﻣﻮﺍﺻﻔﺎﺕ ﺍﳋﻂ‬
‫ﺃﺩﺍﺓ ﺍﻟﺤﻭﺍﺭ ﻟﺘﻐﻴﻴﺭ ﺍﻟﻠﻭﻥ‬

‫ﻻ ﺘﺨﺘﻠﻑ ﺃﺩﺍﺓ ﺤﻭﺍﺭ ﺍﻷﻟﻭﺍﻥ ﻋﻥ ﻗﺭﻴﻨﺘﻬﺎ ﺍﻟﺴﺎﺒﻘﺔ ﺃﺩﺍﺓ ﺤﻭﺍﺭ ﺍﻟﺨﻁ‪ .‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻷﺩﺍﺓ ﻟﺘﻐﻴﻴﺭ‬
‫ﺨﺎﺼﻴﺔ ﺍﻟﻠﻭﻥ ﻷﺩﺍﺓ ﻤﺎ‪ ،‬ﻓﻌﻠﻰ ﺴﺒﻴل ﺍﻟﻤﺜﺎل ﺃﺩﺍﺓ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻴﻭﺠﺩ ﻟﻬﺎ ﺨﺎﺼﻴﺘﻴﻥ ﺘﺘﻌﻠﻘﺎﻥ‬
‫ﺒﺎﻷﻟﻭﺍﻥ‪ ،‬ﺍﻷﻭﻟﻰ ﻫﻲ ﺨﺎﺼﻴﺔ ‪ ForColor‬ﻭ ﺍﻟﺜﺎﻨﻴﺔ ﻫﻲ ﺨﺎﺼﻴﺔ ‪ .BackColor‬ﺘﺴﺘﻁﻴﻊ ﻤﻥ‬
‫ﺨﻼل ﺃﺩﺍﺓ ﺤﻭﺍﺭ ﺍﻷﻟﻭﺍﻥ ﺘﻐﻴﻴﺭ ﺃﻴﺎ ﻤﻥ ﻫﺎﺘﻴﻥ ﺍﻟﺨﺎﺼﻴﺘﻴﻥ‪.‬‬
‫ﻗﻡ ﺒﺈﻀﺎﻓﺔ ﺍﻷﺩﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻭ ﺃﻋﻁﻬﺎ ﺍﻟﺨﺼﺎﺌﺹ ﻜﻤﺎ ﻓﻲ ﺍﻟﺠﺩﻭل ‪:‬‬

‫‪cmdChangeColor‬‬ ‫‪Name‬‬ ‫‪Button1‬‬
‫ﺘﻐﻴﻴﺭ ﺍﻷﻟﻭﺍﻥ‬ ‫‪Text‬‬
‫‪ColorDialog1‬‬ ‫‪Name‬‬ ‫‪ColorDialog‬‬
‫ﺍﻨﻘﺭ ﻤﺯﺩﻭﺠﺎ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ ﻭ ﺍﻜﺘﺏ ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ ﺜﻡ ﻨﻔﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺍﻨﻘﺭ ﺯﺭ ﺍﻷﻤﺭ ﻟﺘﺭﻯ‬
‫ﺍﻟﺸﻜل)‪:(١١-١١‬‬
‫‪With ColorDialog1‬‬
‫‪.SolidColorOnly = True‬‬
‫‪Button1.BackColor = .Color‬‬
‫‪Label1.ForeColor = .color‬‬
‫‪End If‬‬
‫ﺷﻜﻞ ‪ : ١١-١١‬ﺍﺧﺘﻴﺎﺭ ﻣﻮﺍﺻﻔﺎﺕ ﺍﻟﻠﻮﻥ‬

‫ﺘﻘﻴﻴﺩ ﻤﺩﺨﻼﺕ ﺍﻟﻤﺴﺘﻔﻴﺩ‬

‫ﻴﻤﻜﻥ ﺘﻌﺭﻴﻑ ﻋﻤﻠﻴﺔ ﺘﺩﻗﻴﻕ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺄﻨﻬﺎ ﺍﻟﺘﺤﻘﻕ ﻤﻥ ﺼﺤﺔ ﺍﻟﻤﺴﺘﻔﻴﺩ ﻭ ﻤﻁﺎﺒﻘﺔ ﻫﺫﻩ ﺍﻟﻤﺩﺨﻼﺕ‬
‫ﻟﻘﻭﺍﻋﺩ ﻭ ﺇﺠﺭﺍﺀﺍﺕ ﺍﻟﻌﻤل‪ .‬ﻟﺫﺍ ﻴﺠﺩﺭ ﺒﻨﺎ ﺃﻥ ﻨﺘﻜﻠﻡ ﻋﻥ ﺃﻗﺴﺎﻡ ﺘﺩﻗﻴﻕ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪:‬‬
‫‪ -١‬ﺘﺩﻗﻴﻕ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﻤﺎ ﻻ ﻴﺘﻁﻠﺏ ﺍﻟﺭﺠﻭﻉ ﺇﻟﻰ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ :‬ﻴﻤﻜﻥ ﺘﺴﻤﻴﺔ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ‬
‫ﺍﻟﺘﺩﻗﻴﻕ ﺒﺎﻟﺘﺩﻗﻴﻕ ﺍﻟﻨﻤﻭﺫﺠﻲ ﻟﻠﺒﻴﺎﻨﺎﺕ –‪ ،-Front End Validation‬ﻓﻲ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ‬
‫ﺍﻟﺘﺩﻗﻴﻕ ﻻ ﺘﺤﺘﺎﺝ ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﻤﻌﺭﻓﺔ ﺩﻗﺔ ﻭ ﺼﺤﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﻴﻘﻭﻡ‬
‫ﺍﻟﻤﺴﺘﻔﻴﺩ ﺒﺈﺩﺨﺎﻟﻬﺎ‪ .‬ﻭﻤﻥ ﺃﻤﺜﻠﺔ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ‪:‬‬
‫• ﺍﻟﺘﺄﻜﺩ ﻤﻥ ﻋﺩﻡ ﺇﺩﺨﺎل ﻗﻴﻤﺔ ﺴﺎﻟﺒﺔ ﻟﺤﻘل ﻻ ﻴﻘﺒل ﺇﻻ ﻗﻴﻤﺔ ﻤﻭﺠﺒﺔ‪.‬‬
‫• ﺍﻟﺘﺄﻜﺩ ﻤﻥ ﻋﺩﻡ ﺘﺠﺎﻭﺯ ﺍﻟﻁﻭل ﺍﻟﻤﺤﺩﺩ ﻟﺤﻘل ﻤﺎ‪.‬‬
‫ﻻﺤﻅ ﺃﻥ ﻜﻼ ﺍﻟﻤﺜﺎﻟﻴﻥ ﺍﻟﺴﺎﺒﻘﻴﻥ ﻻ ﻴﺘﻁﻠﺏ ﺃﻱ ﺭﺠﻭﻉ ﺇﻟﻰ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﺫﺍ ﻴﺘﻡ ﺒﻨﺎﺀ ﻫﺫﺍ‬
‫ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﺘﺩﻗﻴﻕ ﻓﻲ ﻭﺍﺠﻬﺎﺕ ﺍﻟﻤﺴﺘﻔﻴﺩ‪.‬‬
‫‪ -٢‬ﺘﺩﻗﻴﻕ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺫﻱ ﻴﻭﺠﺏ ﺍﻟﺭﺠﻭﻉ ﺇﻟﻰ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ :‬ﻴﻤﻜﻥ ﺘﺴﻤﻴﺔ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ‬
‫ﺍﻟﺘﺩﻗﻴﻕ ﺒﺎﻟﺘﺩﻗﻴﻕ ﺍﻟﺨﻠﻔﻲ ﻟﻠﺒﻴﺎﻨﺎﺕ –‪ ،-Back End Validation‬ﻓﻲ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﺘﺩﻗﻴﻕ‬
‫ﻴﺘﻭﺠﺏ ﺍﻟﺭﺠﻭﻉ ﺇﻟﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﺍﻟﺘﺄﻜﺩ ﻤﻥ ﻤﺩﺨﻼﺕ ﺍﻟﻤﺴﺘﻔﻴﺩ ﻗﺒل ﺘﻨﻔﻴﺫ ﺍﻟﻌﻤﻠﻴﺔ‬
‫ﺍﻟﻤﻁﻠﻭﺒﺔ ﺤﺘﻰ ﻻ ﻴﺘﻡ ﻤﺨﺎﻟﻔﺔ ﻗﻭﺍﻋﺩ ﻭ ﺇﺠﺭﺍﺀﺍﺕ ﺍﻟﻌﻤل‪ .‬ﻤﻥ ﺍﻷﻤﺜﻠﺔ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ‪:‬‬
‫• ﻋﻨﺩ ﺇﺩﺨﺎل ﺇﺠﺎﺯﺓ ﺠﺩﻴﺩﺓ ﻟﻤﻭﻅﻑ ﻴﺠﺏ ﺍﻟﺘﺄﻜﺩ ﻤﻥ ﺃﻥ ﻫﺫﺍ ﺍﻟﻤﻭﻅﻑ ﻟﻡ ﻴﺴﺘﻨﻔﺫ ﺭﺼﻴﺩﻩ‬
‫ﻤﻥ ﺍﻷﺠﺎﺯﺍﺕ‪ ،‬ﻻ ﻴﻤﻜﻥ ﻋﻤل ﻫﺫﺍ ﺍﻟﺘﺩﻗﻴﻕ ﺇﻻ ﺒﻌﺩ ﺍﻟﺭﺠﻭﻉ ﺇﻟﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺜﻡ‬
‫ﺤﺴﺎﺏ ﺍﻷﺠﺎﺯﺍﺕ ﺍﻟﺘﻲ ﺴﺒﻕ ﺃﻥ ﺃﺨﺫﻫﺎ ﺍﻟﻤﻭﻅﻑ‪.‬‬
‫• ﻤﺜﺎل ﺁﺨﺭ ﻤﺎﺫﺍ ﻟﻭ ﺃﺭﺩﻨﺎ ﺃﻥ ﻨﺼﺭﻑ ﻤﺎﺩﺓ ﻤﻥ ﻤﺴﺘﻭﺩﻉ ‪ ،‬ﻴﺠﺏ ﺍﻟﺘﺄﻜﺩ ﻤﻥ ﺭﺼﻴﺩ ﺍﻟﻤﺎﺩﺓ‬
‫ﻗﺒل ﺼﺭﻓﻬﺎ‪.‬‬
‫ﻓﻲ ﺍﻟﻤﺜﺎﻟﻴﻥ ﺍﻟﺴﺎﺒﻘﻴﻥ ﻻﺒﺩ ﻤﻥ ﺍﻟﺭﺠﻭﻉ ﺇﻟﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﺘﻁﺒﻴﻕ ﺘﻠﻙ ﺍﻟﺘﺩﻗﻴﻘﺎﺕ‪.‬‬
‫‪120‬‬
‫ﺍﻟﺘﺩﻗﻴﻕ ﺍﻟﻨﻤﻭﺫﺠﻲ ﻟﻠﺒﻴﺎﻨﺎﺕ‬

‫ﺇﺭﺸﺎﺩﺍﺕ ﻟﺘﺩﻗﻴﻕ ﻤﺩﺨﻼﺕ ﺍﻟﻤﺴﺘﻔﻴﺩ‬
‫ﺘﻭﺠﺩ ﺒﻌﺽ ﺍﻹﺭﺸﺎﺩﺍﺕ ﺍﻟﻌﺎﻤﺔ ﻋﻨﺩ ﺍﻟﺘﺩﻗﻴﻕ ﺍﻟﻨﻤﻭﺫﺠﻲ ﻟﻠﺒﻴﺎﻨﺎﺕ ﻭﻫﻲ ‪:‬‬
‫• ﺍﻤﻨﻊ ﺍﻟﻤﺴﺘﻔﻴﺩ ﻤﻥ ﺇﺩﺨﺎل ﺒﻴﺎﻨﺎﺕ ﻏﻴﺭ ﺼﺤﻴﺤﺔ ﺇﻥ ﺃﻤﻜﻥ ﻤﺜل ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻘﻭﺍﺌﻡ ﻜﻠﻤﺎ ﺃﻤﻜﻥ‬
‫ﺫﻟﻙ‪.‬‬
‫• ﺃﺭﺸﺩ ﺍﻟﻤﺴﺘﻔﻴﺩ ﺃﺜﻨﺎﺀ ﻋﻤﻠﻴﺔ ﺇﺩﺨﺎل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻟﻰ ﺍﺴﻡ ﺍﻟﺤﻘل ﺍﻟﺫﻱ ﻴﺤﻤل ﺍﻟﺨﻁﺄ ﻤﻌﻴﺩﺍ ﺇﻟﻴﻪ‬
‫ﺍﻟﻤﺅﺸﺭ‪.‬‬
‫• ﺍﻤﻨﺢ ﺍﻟﻤﺭﻭﻨﺔ ﻟﻠﻤﺴﺘﻔﻴﺩ ﻋﻠﻰ ﺇﺩﺨﺎل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺎﻟﺘﺭﺘﻴﺏ ﺍﻟﺫﻱ ﻴﺭﻴﺩﻩ ﻫﻭ ﻤﺎ ﻟﻡ ﻴﻜﻥ ﻫﻨﺎﻙ ﺤﻘل‬
‫ﻴﻌﺘﻤﺩ ﻋﻠﻰ ﺁﺨﺭ‪.‬‬
‫• ﺨﺫ ﺒﻌﻴﻥ ﺍﻻﻋﺘﺒﺎﺭ ﻜل ﺃﻨﻭﺍﻉ ﺍﻟﺘﺩﻗﻴﻕ ﻭ ﻗﻭﺍﻋﺩ ﺍﻟﻌﻤل ﺃﺜﻨﺎﺀ ﻋﻤﻠﻴﺔ ﺘﺤﻠﻴل ﻭ ﺘﺼﻤﻴﻡ ﺍﻟﻨﻅﺎﻡ‪.‬‬
‫ﺍﻟﺘﺩﻗﻴﻕ ﺍﻟﺫﺍﺘﻲ ﻟﻸﺩﻭﺍﺕ‬

‫ﺒﻤﺎ ﺃﻨﻨﺎ ﻓﻲ ﺍﻟﻨﻭﻉ ﺍﻷﻭل ﻤﻥ ﺃﻨﻭﺍﻉ ﺍﻟﺘﺩﻗﻴﻕ ﻭﻫﻭ ﺍﻟﺘﺩﻗﻴﻕ ﺍﻟﻨﻤﻭﺫﺠﻲ ﻓﺈﻥ ﺠﺯﺀ ﻤﻥ ﺘﻁﺒﻴﻕ ﻫﺫﺍ ﺍﻟﻨﻭﻉ‬
‫ﻴﻌﺘﻤﺩ ﻋﻠﻰ ﺍﻷﺩﻭﺍﺕ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻓﻲ ﺍﻟﻨﻤﻭﺫﺝ‪ ،‬ﺒﻌﺽ ﺍﻷﺩﻭﺍﺕ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﺘﺴﺎﻋﺩﻙ ﻓﻲ ﺇﺠﺭﺍﺀ‬
‫ﺍﻟﺘﺩﻗﻴﻕ‪.‬‬
‫ﻴﻤﻜﻥ ﺘﻌﺭﻴﻑ ﺍﻟﺘﺩﻗﻴﻕ ﺍﻟﺫﺍﺘﻲ ﻟﻸﺩﻭﺍﺕ ﺒﺄﻨﻪ ﺍﻟﺘﺩﻗﻴﻕ ﺍﻟﺫﻱ ﻴﺘﻭﻓﺭ ﻟﻜل ﺃﺩﺍﺓ ﻤﻥ ﺨﻼل ﺨﺼﺎﺌﺼﻬﺎ‪.‬‬
‫ﺍﻟﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﺒﻌﺽ ﺍﻷﻤﺜﻠﺔ ﻋﻠﻰ ﺍﻟﺘﺩﻗﻴﻕ ﺍﻟﺫﺍﺘﻲ ﻟﻸﺩﻭﺍﺕ ‪:‬‬
‫أﺳﻠﻮب اﻟﺘﺪﻗﻴﻖ‬ ‫اﻟﻜﺎﺋﻦ‬

‫ﺗﺤﺪﻳﺪ أو ﺗﻌﺪﻳﻞ اﻟﺒﻴﺎﻧﺎت اﻟﻤﺪﺧﻠﺔ‪.‬‬ ‫ﻣﺮﺑﻊ اﻟﻨﺺ‬
‫ﺣﺼﺮ اﻟﻘﻴﻢ ﺑﺎﺧﺘﻴﺎر أو ﻋﺪﻣﻪ‪.‬‬ ‫ﻣﺮﺑﻊ اﻻﺧﺘﻴﺎر‬
‫اﺧﺘﻴﺎر ﻗﻴﻤﺔ واﺣﺪة‪.‬‬ ‫زر اﻻﺧﺘﻴﺎر‬
‫ﺗﻘﺪم ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺒﻴﺎﻧﺎت اﻟﺼﺤﻴﺤﺔ‪.‬‬ ‫اﻟﻘﺎﺋﻤﺔ‬
‫ﺣﺼﺮ اﻟﻤﺪﺧﻼت ﺑﺎﻟﺘﺎرﻳﺦ‪.‬‬ ‫أداة اﻟﺘﺎرﻳﺦ‬
‫‪121‬‬
‫ﺍﻟﺘﺩﻗﻴﻕ ﺍﻟﺫﺍﺘﻲ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ‬

‫ﻴﻤﻜﻥ ﺇﺠﺭﺍﺀ ﺍﻟﺘﻁﺒﻴﻕ ﺍﻟﺫﺍﺘﻲ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺒﺎﺴﺘﺨﺩﺍﻡ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺨﺼﺎﺌﺹ ﻭﻫﻲ ‪:‬‬
‫‪ : PasswordChar -١‬ﺘﻤﻜﻨﻙ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻤﻥ ﺘﻐﻴﻴﺭ ﺸﻜل ﺍﻟﻤﺩﺨﻼﺕ ﺇﻟﻰ ﺭﻤﻭﺯ ﺘﺤﺠﺏ‬
‫ﺍﻟﻜﻠﻤﺎﺕ ﺍﻟﻤﺩﺨﻠﺔ ﺇﻟﻰ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻜﻤﺎ ﻴﺘﻀﺢ ﻤﻥ ﺍﻟﺸﻜل)‪.(١-١٠‬‬
‫ﺷﻜﻞ ‪ : 1-١٠‬ﺍﺳﺘﺨﺪﺍﻡ ﺧﺎﺻﻴﺔ ‪PasswordChar‬‬
‫‪ : MaxLength -٢‬ﺘﺴﺘﺨﺩﻡ ﻹﻋﻁﺎﺀ ﺤﺩ ﺃﻗﺼﻰ ﻟﻌﺩﺩ ﺍﻟﺤﺭﻭﻑ ﺍﻟﻤﺩﺨﻠﺔ ﺇﻟﻰ ﻤﺭﺒﻊ ﺍﻟﻨﺹ‪ .‬ﻋﻨﺩ‬
‫ﻤﺤﺎﻭﻟﺔ ﺘﺨﻁﻲ ﺍﻟﻌﺩﺩ ﺍﻷﻗﺼﻰ ﻓﺈﻥ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻟﻥ ﻴﺴﻤﺢ ﻟﻙ ﺒﺎﻟﻜﺘﺎﺒﺔ ﻭﺴﻭﻑ ﺘﺴﻤﻊ ﻨﻐﻤﺔ‬
‫ﺒﻴﺏ ﺇﻥ ﺤﺎﻭﻟﺕ ﺍﻟﺯﻴﺎﺩﺓ ﻋﻠﻰ ﺍﻟﺤﺩ ﺍﻷﻗﺼﻰ‪.‬‬
‫‪ : ReadOnly -٣‬ﺘﺴﺘﺨﺩﻡ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻟﻤﻨﻊ ﺍﻟﻤﺴﺘﻔﻴﺩ ﻤﻥ ﺇﺩﺨﺎل ﺃﻱ ﻨﺹ ﺇﻟﻰ ﻤﺭﺒﻊ ﺍﻟﻨﺹ‬
‫ﻗﻡ ﺒﺈﻋﻤﺎل ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ‪ .‬ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﻴﺴﺘﻁﻴﻊ ﺍﻟﻤﺴﺘﻔﻴﺩ ﺭﺅﻴﺔ ﻤﺎ ﻫﻭ ﻤﻜﺘﻭﺏ ﻓﻲ ﻤﺭﺒﻊ‬
‫ﺍﻟﻨﺹ ﻟﻜﻥ ﻟﻥ ﻴﺴﺘﻁﻴﻊ ﺘﻐﻴﻴﺭ ﺍﻟﻨﺹ‪.‬‬
‫‪ : CharcterCasing -٤‬ﺘﺴﺘﺨﺩﻡ ﻟﻠﺘﺤﻭﻴل ﺍﻵﻟﻲ ﺒﻴﻥ ﺤﺎﻻﺕ ﺍﻟﺤﺭﻭﻑ – ﺼﻐﻴﺭ ﺃﻭ ﻜﺒﻴﺭ – ﻗﺩ‬
‫ﻴﻜﻭﻥ ﻤﻥ ﺍﻟﻤﻔﻴﺩ ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﻓﻲ ﺍﻟﻜﻠﻤﺔ ﺍﻟﺴﺭﻴﺔ ﺇﺫﺍ ﻜﺎﻨﺕ ﻜﻠﻤﺔ ﺍﻟﺴﺭ ﻋﺒﺎﺭﺓ ﻋﻥ ﺤﺭﻭﻑ‬
‫ﺼﻐﻴﺭﺓ‪.‬‬
‫ﻜﻴﻑ ﺘﺴﺘﺨﺩﻡ ﻜﺎﺌﻥ ﻤﺯﻭﺩ ﺍﻷﺨﻁﺎﺀ‬
‫ﻴﺴﺘﺨﺩﻡ ﻜﺎﺌﻥ ﻤﺯﻭﺩ ﺍﻷﺨﻁﺎﺀ ‪ ErrorProvider‬ﻟﺘﻨﺒﻴﻪ ﺍﻟﻤﺴﺘﻔﻴﺩ ﺇﻟﻰ ﺍﻷﺨﻁﺎﺀ ﻭﻁﺭﻕ ﺇﺼﻼﺤﻬﺎ‪.‬‬
‫ﻴﺘﻤﻴﺯ ﻋﻥ ﻤﺭﺒﻊ ﺍﻟﺭﺴﺎﻟﺔ ﺒﺄﻨﻪ ﻻ ﻴﻔﺘﺢ ﻨﺎﻓﺫﺓ ﺃﺨﺭﻯ ﻟﻠﻤﺴﺘﻔﻴﺩ ﻜﻤﺎ ﺃﻨﻪ ﻴﻅل ﻤﻭﺠﻭﺩﺍ ﺃﻤﺎﻡ ﻋﻴﻥ‬
‫ﺍﻟﻤﺴﺘﻔﻴﺩ ﺤﺘﻰ ﻴﺼﻠﺢ ﺍﻟﺨﻁﺄ ﻭﻫﻭ ﻤﺎﻻ ﻴﺘﻭﻓﺭ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﺭﺴﺎﻟﺔ‪ .‬ﺇﺫﺍ ﺃﻀﻔﺕ ﺃﺩﺍﺓ ﻭﺍﺤﺩﺓ ﻤﻥ ﻤﺯﻭﺩ‬
‫ﺍﻷﺨﻁﺎﺀ ﻓﺈﻨﻬﺎ ﺘﻜﻔﻴﻙ ﻟﻜل ﺍﻟﺘﺩﻗﻴﻘﺎﺕ ﻓﻲ ﺍﻟﻨﻤﻭﺫﺝ‪ .‬ﺃﻫﻡ ﻁﺭﻴﻘﺔ ﻟﻬﺫﻩ ﺍﻷﺩﺍﺓ ﻫﻲ ‪SetError‬‬
‫ﻭ ﺍﻟﺘﻲ ﺘﺴﺘﺨﺩﻡ ﻟﺒﻴﺎﻥ ﺍﻷﺨﻁﺎﺀ‪.‬‬
‫‪122‬‬
‫ﻗﻡ ﺒﺈﻀﺎﻓﺔ ﻨﻤﻭﺫﺝ ﻭﺃﻀﻑ ﻓﻴﻪ ﺍﻷﺩﻭﺍﺕ ﺤﺴﺏ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﺠﺩﻭل ﻭ‬
‫ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل )‪(٢-١٠‬‬

‫‪cmdValidate‬‬ ‫‪Name‬‬ ‫‪Button1‬‬
‫ﺘﺩﻗﻴﻕ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫‪Text‬‬
‫‪Textbox1‬‬ ‫‪Name‬‬ ‫‪Textbox‬‬
‫‪Text‬‬
‫‪Text‬‬
‫‪er‬‬ ‫‪Name ErrorProvider‬‬
‫‪frmErrorTest‬‬ ‫‪Name‬‬ ‫‪Form‬‬
‫ﺷﻜﻞ ‪ : ٣-١٠‬ﻇﻬﻮﺭ ﺭﺳﺎﻟﺔ ﺗﻨﺒﻴﻪ ﻣﻦ ﻣﺰﻭﺩ ﺍﻷﺧﻄﺎﺀ‬ ‫ﺷﻜﻞ ‪٢-١٠ :‬‬
‫ﻗﻡ ﺒﻜﺘﺎﺒﺔ ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ ﺩﺍﺨل ﺤﺩﺙ ﺍﻟﻨﻘﺭ ﺍﻟﺨﺎﺹ ﺒﺯﺭ ﺍﻷﻤﺭ ‪:‬‬
‫‪If Trim(TextBox1.Text) = "" Then‬‬

‫)"ﻗﻴﻤﺔ إدﺧﺎل ﻳﺮﺟﻰ" ‪er.SetError(TextBox1,‬‬
‫‪Else‬‬
‫)"" ‪er.SetError(TextBox1,‬‬
‫‪End If‬‬
‫ﻓﻲ ﺍﻟﻜﻭﺩ ﺍﻟﺴﺎﺒﻕ ﻨﻘﻭﻡ ﺒﻤﺎ ﻴﻠﻲ ‪:‬‬

‫‪ -١‬ﻨﺘﺄﻜﺩ ﻫل ﺃﺩﺨل ﺍﻟﻤﺴﺘﻔﻴﺩ ﻨﺼﺎ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺃﻡ ﻻ‪.‬‬
‫‪ -٢‬ﻨﻘﻭﻡ ﺒﺈﻅﻬﺎﺭ ﺭﺴﺎﻟﺔ ﺨﻁﺄ ﻤﻥ ﺨﻼل ﻤﺯﻭﺩ ﺍﻷﺨﻁﺎﺀ ﻭ ﺍﻟﺫﻱ ﺍﺴﻤﻪ ‪ .er‬ﺭﺴﺎﻟﺔ ﺍﻟﺨﻁﺄ ﺴﻭﻑ‬
‫ﺘﻅﻬﺭ ﻋﻨﺩ ﻤﺭﻭﺭ ﺍﻟﻔﺄﺭﺓ ﻋﻠﻰ ﻤﺯﻭﺩ ﺍﻟﺨﻁﺄ ﻜﻤﺎ ﺘﺭﻯ ﻤﻥ ﺍﻟﺸﻜل )‪.(٣-١٠‬‬
‫‪ -٣‬ﺇﺫﺍ ﺃﺩﺨل ﺍﻟﻤﺴﺘﻔﻴﺩ ﻨﺼﺎ ﻨﻘﻭﻡ ﺒﺈﺯﺍﻟﺔ ﺭﺴﺎﻟﺔ ﺍﻟﺨﻁﺄ‪.‬‬
‫‪123‬‬
‫ﺘﺩﻗﻴﻕ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺠﻤﻠﺔ ﻭﺍﺤﺩﺓ‬

‫ﺇﺫﺍ ﺃﺭﺩﺕ ﺍﻟﻘﻴﺎﻡ ﺒﺈﺠﺒﺎﺭ ﺍﻟﻤﺴﺘﻔﻴﺩ ﺒﺈﺩﺨﺎل ﺒﻴﺎﻨﺎﺕ ﻓﻲ ﻜل ﺍﻷﺩﻭﺍﺕ ﻤﻥ ﻨﻭﻉ ﻤﺭﺒﻊ ﻨﺹ ﺒﺩﻭﻥ ﺃﻥ‬
‫ﺘﺘﺄﻜﺩ ﻤﻥ ﻜل ﺃﺩﺍﺓ ﻋﻠﻰ ﺤﺩﺓ ﻓﺈﻟﻴﻙ ﻫﺫﺍ ﺍﻟﻤﺜﺎل ﺍﻟﺫﻱ ﻴﻭﻓﺭ ﻟﻙ ﺍﻟﻭﻗﺕ ﻭ ﺍﻟﺠﻬﺩ ‪:‬‬
‫‪Dim ControlVar As Control‬‬
‫‪For Each ControlVar In Me.Controls‬‬
‫‪If TypeOf ControlVar Is TextBox Then‬‬
‫‪If Trim(ControlVar.Text) = "" Then‬‬
‫)"ﻴﺭﺠﻰ ﺇﺩﺨﺎل ﺍﻟﺒﻴﺎﻨﺎﺕ" ‪erReq.SetError(ControlVar,‬‬
‫‪Else‬‬
‫)"" ‪erReq.SetError(ControlVar,‬‬
‫‪End If‬‬
‫‪End If‬‬
‫‪Next‬‬

‫‪ -١‬ﻋﺭﻓﻨﺎ ﻤﺘﻐﻴﺭ ﻤﻥ ﻨﻭﻉ ﺃﺩﺍﺓ ‪.‬‬
‫‪ -٢‬ﻗﻤﻨﺎ ﺒﺎﻟﻤﺭﻭﺭ ﻋﻠﻰ ﻜل ﺍﻷﺩﻭﺍﺕ ﺩﺍﺨل ﺍﻟﻨﻤﻭﺫﺝ ﻤﻥ ﺨﻼل ﺘﻜﺭﺍﺭ ﻓﺈﺫﺍ ﻜﺎﻥ ﻨﻭﻉ ﺍﻷﺩﺍﺓ ﻤﺭﺒﻊ‬
‫ﻨﺹ ﻨﻘﻭﻡ ﺒﺎﻟﺘﺄﻜﺩ ﻫل ﻴﻭﺠﺩ ﻓﻴﻬﺎ ﻨﺹ ﺃﻡ ﻻ‪ ،‬ﻓﺈﺫﺍ ﻟﻡ ﻴﻜﻥ ﺒﻬﺎ ﻨﺹ ﻨﻘﻭﻡ ﺒﺈﻅﻬﺎﺭ ﺭﺴﺎﻟﺔ ﺨﻁﺄ‬
‫ﻤﻥ ﺨﻼل ﻤﺯﻭﺩ ﺍﻷﺨﻁﺎﺀ‪.‬‬
‫‪124‬‬
‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻭ ﺍﻟﺜﻭﺍﺒﺕ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‬
‫ﻴﻤﻜﻥ ﺘﻌﺭﻴﻑ ﺍﻟﻤﺘﻐﻴﺭ ﺒﺄﻨﻪ ﻤﺎ ﻴﻤﻜﻥ ﺃﻥ ﻴﺤﻤل ﻗﻴﻤﺎ ﻤﺘﻨﻭﻋﺔ ﺃﺜﻨﺎﺀ ﻋﻤل ﺍﻟﻨﻅﺎﻡ ﻭ ﻤﻥ ﺜﻡ ﻴﺴﻬل ﺘﻌﺭﻴﻑ‬
‫ﺍﻟﺜﺎﺒﺕ ﺒﺄﻨﻪ ﻤﺎ ﻴﺤﻤل ﻗﻴﻤﺔ ﻭﺍﺤﺩﺓ ﺘﺴﻨﺩ ﺇﻟﻴﻪ ﻋﻨﺩ ﺘﻌﺭﻴﻔﻪ ﻭﻻ ﻴﻤﻜﻥ ﺘﻐﻴﻴﺭ ﻫﺫﻩ ﺍﻟﻘﻴﻤﺔ ﺒﻌﺩ ﺫﻟﻙ‪ .‬ﺘﺨﺘﻠﻑ‬
‫ﻁﺭﻴﻘﺔ ﺘﻌﺭﻴﻑ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻋﻥ ﻁﺭﻴﻘﺔ ﺘﻌﺭﻴﻑ ﺍﻟﺜﻭﺍﺒﺕ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‪ .‬ﻜل ﻤﺘﻐﻴﺭ ﻓﻲ ﺒﻴﺌﺔ‬
‫ﺍﻟﺩﻭﺕ ﻨﺕ ﻟﻪ ﻤﺠﺎل‪ ،‬ﺒﻌﺩ ﺘﻌﺩﻱ ﻫﺫﺍ ﺍﻟﻤﺠﺎل ﻴﻔﻘﺩ ﺍﻟﻤﺘﻐﻴﺭ ﻗﻴﻤﺘﻪ ﻟﺫﺍ ﻤﻥ ﺍﻟﻀﺭﻭﺭﻱ ﻤﻌﺭﻓﺔ ﻤﺠﺎل‬
‫ﺍﻟﻤﺘﻐﻴﺭ ﺃﻭ ﻤﺎ ﻴﺴﻤﻰ ﺒﻔﺘﺭﺓ ﺤﻴﺎﺓ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ‪.‬‬
‫ﺘﻌﺭﻴﻑ ﺍﻟﻤﺘﻐﻴﺭ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‬
‫ﻴﻤﻜﻨﻙ ﺘﻌﺭﻴﻑ ﺍﻟﻤﺘﻐﻴﺭ ﺍﻟﺠﺩﻴﺩ ﻓﻲ ﺒﻴﺌﺔ ‪ Visual Basic .NET‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﻋﺒﺎﺭﺓ ‪Dim .‬‬
‫ﻜﻤﺎ ﻴﻠﻲ ‪:‬‬
‫‪Dim Variable as DataType‬‬
‫ﻫﻨﺎﻙ ﺃﺭﺒﻌﺔ ﺃﺠﺯﺍﺀ ﻟﻌﺒﺎﺭﺓ ﺘﻌﺭﻴﻑ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ‪:‬‬
‫‪ Dim -١‬ﻭ ﺘﻤﺜل ﻤﺠﺎل ﺍﻟﻤﺘﻐﻴﺭ ﻭﺴﻭﻑ ﻨﺘﻜﻠﻡ ﻋﻥ ﻤﺠﺎﻻﺕ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺒﺎﻟﺘﻔﺼﻴل‪.‬‬
‫‪ Variable -٢‬ﺘﻤﺜل ﺍﺴﻡ ﺘﻘﻭﻡ ﺃﻨﺕ ﺒﺈﻋﻁﺎﺌﻪ ﻟﻠﻤﺘﻐﻴﺭ‪.‬‬
‫‪ As -٣‬ﻭﻫﻲ ﻜﻠﻤﺔ ﻤﺤﺠﻭﺯﺓ ﻻ ﻴﻤﻜﻨﻙ ﺘﻐﻴﻴﺭﻫﺎ‪.‬‬
‫‪ DataType -٤‬ﻭ ﻴﻤﺜل ﻨﻭﻉ ﺍﻟﻤﺘﻐﻴﺭ ﺴﻭﺍﺀ ﺤﺭﻭﻑ ﺃﻭ ﺃﺭﻗﺎﻡ ﺃﻭ ﺘﺎﺭﻴﺦ ﺃﻭ ﻏﻴﺭﻩ‪.‬‬
‫‪Address، Phone‬‬ ‫ﻋﻠﻰ ﺴﺒﻴل ﺍﻟﻤﺜﺎل ‪,‬ﺍﻟﺠﻤﻠﺔ ﺍﻟﺘﺎﻟﻴﺔ ﺘﻘﻭﻡ ﺒﺘﻌﺭﻴﻑ ﻤﺘﻐﻴﺭﺍﻥ‬
‫‪Dim Phone As Integer‬‬

‫‪Dim Address‬‬
‫‪44‬‬
‫ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻷﻭل ﻗﻤﻨﺎ ﺒﺘﻌﺭﻴﻑ ﻤﺘﻐﻴﺭ ﺍﺴﻤﻪ ‪ Phone‬ﻤﻥ ﻨﻭﻉ ﺭﻗﻡ ﺼﺤﻴﺢ ﺜﻡ ﻻﺤﻅ ﺃﻨﻨﺎ ﻋﺭﻓﻨﺎ‬
‫ﻤﺘﻐﻴﺭ ﻭﻫﻭ ‪ Address‬ﻟﻜﻨﻨﺎ ﻟﻡ ﻨﺫﻜﺭ ﻨﻭﻋﻪ –ﺴﻴﺄﺘﻲ ﻻﺤﻘﺎ ﺃﻨﻭﺍﻉ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ‪ -‬ﻭﻫﻭ ﻤﺎ ﻴﻌﺘﺒﺭ ﺤﻼ‬
‫ﻏﻴﺭ ﻤﺜﺎﻟﻴﺎ ﻓﻲ ﺍﻟﻅﺭﻭﻑ ﺍﻻﻋﺘﻴﺎﺩﻴﺔ ﻟﻌﺩﺓ ﺃﺴﺒﺎﺏ ‪:‬‬
‫‪ -١‬ﻋﺩﻡ ﺍﻟﻘﺩﺭﺓ ﻋﻠﻰ ﺘﻤﻴﻴﺯ ﻨﻭﻉ ﺍﻟﻤﺘﻐﻴﺭ‪.‬‬
‫‪ -٢‬ﻗﺩ ﺘﺤﺼل ﺃﺨﻁﺎﺀ ﻏﻴﺭ ﻤﻘﺼﻭﺩﺓ ﻤﺜل ﺇﺴﻨﺎﺩ ﻤﺘﻐﻴﺭ ﻤﻥ ﻨﻭﻉ ﺇﻟﻰ ﻤﺘﻐﻴﺭ ﻤﻥ ﻨﻭﻉ ﺁﺨﺭ ﻭﻫﻭ‬
‫ﻤﺎ ﻗﺩ ﻴﺴﺒﺏ ﺨﻠﻼ ﻓﻲ ﺃﺩﺍﺀ ﺍﻟﻨﻅﺎﻡ‪.‬‬
‫‪ -٣‬ﺍﺴﺘﺨﺩﺍﻡ ﻏﻴﺭ ﻤﺜﺎﻟﻲ ﻟﻠﺫﺍﻜﺭﺓ ﻤﻤﺎ ﻴﺴﺒﺏ ﺒﻁﺄ ﻓﻲ ﺘﻨﻔﻴﺫ ﺍﻟﻨﻅﺎﻡ‪.‬‬
‫ﻋﻨﺩ ﻋﺩﻡ ﺘﺤﺩﻴﺩ ﻨﻭﻉ ﺍﻟﻤﺘﻐﻴﺭ ﻓﺈﻥ ﻨﻭﻉ ﺍﻟﻤﺘﻐﻴﺭ ﻴﻤﺜﹼل ﻨﻭﻉ ﻜﺎﺌﻥ ‪ ، Object‬ﻫﺫﺍ ﺍﻟﻨﻭﻉ‬
‫ﻱ ﻨﻭﻉ ﻤﻥ ﺃﻨﻭﺍﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ‪.‬ﺴﻭﺍﺀ ﻨﻭﻉ ﺍﻟﺤﺭﻭﻑ )‪(String‬‬
‫ﻴﻤﻜﻥ ﺃﻥ ﻴﻤﺜﹼل ﺃ ‪‬‬
‫ﺃﻭ ﺍﻷﻋﺩﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ )‪ (Integer‬ﺃﻭ ﺃﻱ ﺃﻨﻭﺍﻉ ﺃﺨﺭﻯ‪.‬‬
‫ﻋﻨﺩﻤﺎ ﺘﺴﺘﺨﺩﻡ ﺍﻟﻤﺘﻐﻴ‪‬ﺭ ﻤﻥ ﻏﻴﺭ ﺫﻜﺭ ﻨﻭﻋﻪ ﻓﺈﻥ ﺍﻟﻨﻭﻉ ﺍﻟﻤﻨﺎﺴﺏ ﻴﺘﺤﺩﺩ ﻓﻲ ﻭﻗﺕ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ‬
‫‪(run-time).‬‬
‫ﻴﻤﺜل ﺍﻟﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ﺒﻌﺽ ﺃﻨﻭﺍﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻭ ﺍﻟﺤﺠﻡ ﺍﻟﺘﺨﺯﻴﻨﻲ ﻟﻜل ﻨﻭﻉ ﻭ‬
‫ﺍﻟﻘﻴﻡ ﺍﻟﻤﺴﻤﻭﺡ ﺒﻬﺎ ﻟﻜل ﻨﻭﻉ‪.‬‬
‫اﻟﻤﺴﺎﺣﺔ اﻟﺘﺨﺰﻳﻨﻴﺔ ﻧﻮع اﻟﺒﻴﺎﻧﺎت‬ ‫اﻟﻘﻴﻢ اﻟﻤﺴﻤﻮح ﺑﻬﺎ‬

‫‪Boolean‬‬ ‫‪4 bytes‬‬ ‫ﺻﺤﻴﺤﺔ )‪ (True‬ﺧﺎﻃﺌﺔ)‪(False‬‬
‫‪Byte‬‬ ‫‪1 byte‬‬ ‫ﻳﻤﺜﻞ ﻋﺪد ﺑﻴﻦ ‪ ٠‬و ‪ ) ٢٥٥‬ﻗﻴﻢ ﻣﻮﺟﺒﺔ ﻓﻘﻂ (‬
‫‪Char‬‬ ‫‪2 bytes‬‬ ‫ﻳﻤﺜﻞ ﺣﺮف واﺣﺪ ﻓﻘﻂ‬
‫‪DateTime 8 bytes‬‬ ‫ﻗﻴﻢ ﺗﺒﺪأ ﻣﻦ ‪ ١-١-١‬م إﻟﻰ ‪-٣١‬دﻳﺴﻤﺒﺮ‪٩٩٩٩-‬‬
‫‪Decimal‬‬ ‫‪12 bytes‬‬ ‫ﻳﻤﺜﻞ اﻷرﻗﺎم اﻟﻌﺸﺮﻳﺔ ) ‪-byte ١٦‬وهﻲ ﻣﻦ ‪ ٠‬اﻟﻰ ﻣﻮﺟﺐ أو ﺳﺎﻟﺐ‬
‫‪(79,228,162,514,264,337,593,543,950,335‬‬
‫‪Int32‬‬ ‫‪4 bytes‬‬ ‫ﻣﻦ ‪ 2,147,483,648 -‬إﻟﻰ ‪2,147,483,647‬‬
‫‪Int64‬‬ ‫‪8 bytes‬‬ ‫ﻣﻦ ‪ 9,223,372,036,854,775,808-‬إﻟﻰ ‪9,223,372,036,854,775,807‬‬
‫‪Object‬‬ ‫‪4 bytes‬‬ ‫أي ﻧﻮع ﻳﻤﻜﻦ أن ﻳﺨﺰن داﺧﻞ هﺬا اﻟﻨﻮع‬
‫‪Int16‬‬ ‫‪2 bytes‬‬ ‫ﻣﻦ ‪ 32,768 -‬إﻟﻰ ‪32,767‬‬
‫‪String‬‬ ‫‪10 bytes + (2‬‬ ‫ﻳﻤﺜﻞ ﻗﻴﻤﺔ ﺣﺮﻓﻴﺔ ﺗﺘﺴﻊ إﻟﻰ ‪ ٢‬ﺑﻠﻴﻮن ﺣﺮف‬
‫)ﻃﻮل اﻟﺴﻠﺴﻠﺔ *‬
‫‪45‬‬
‫ﻻﺤﻅ ﻅﻬﻭﺭ ﺒﻌﺽ ﺍﻷﻨﻭﺍﻉ ﺍﻟﺠﺩﻴﺩﺓ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻤﺜل ‪ int16‬ﻭ ‪int32‬‬
‫ﻟﻤﺤﺔ ﻋﻥ ﺒﻌﺽ ﺃﻨﻭﺍﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ﺴﻭﻑ ﻨﺭﻯ ﺜﻼﺜﺔ ﻤﻥ ﺃﻨﻭﺍﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﻤﺎﺫﺍ ﺤﺩﺙ ﻟﻬﺎ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‪.‬‬
‫ﺍﻷﻋﺩﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ ‪Integer‬‬
‫ﻜﻤﺎ ﺴﺒﻕ ﻭ ﺭﺃﻴﺕ ﻴﻭﺠﺩ ﻋﺩﺓ ﺃﻨﻭﺍﻉ ﻤﻥ ﺍﻷﻋﺩﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ ﻓﻬﻨﺎﻙ ‪ Int32‬ﻭ ‪ int16‬ﻭ ‪ int64‬ﻭ‬
‫ﻏﻴﺭﻫﺎ ﻤﻥ ﺍﻷﻨﻭﺍﻉ‪ .‬ﺍﻟﺘﻌﺭﻴﻔﺎﻥ ﺍﻟﺘﺎﻟﻴﺎﻥ ﻴﻌﺘﺒﺭﺍﻥ ﻤﺘﺴﺎﻭﻴﺎﻥ‬
‫‪Dim Phone As Integer‬‬
‫‪Dim Phone As Int32‬‬
‫ﻋﻨﺩ ﺘﻌﺭﻴﻔﻙ ﻟﻤﺘﻐﻴﺭ ﻋﻠﻰ ﺃﻨﻪ ﻤﻥ ﻨﻭﻉ ‪ Integer‬ﻓﺈﻨﻪ ﺴﻭﻑ ﻴﺘﻡ ﺘﺭﺠﻤﺘﻪ ﺇﻟﻰ ‪.int32‬‬
‫ﻻﺤﻅ ﺃﻥ ﻋﻤﻠﻴﺎﺕ ‪ Int32‬ﺃﺴﺭﻉ ﺒﻜﺜﻴﺭ ﻤﻥ ﻋﻤﻠﻴﺎﺕ ‪ int16‬ﻭ ‪ .Int64‬ﻭﻫﻭ ﻤﺎ ﻴﻌﻨﻲ ﺃﻥ ﺍﻟﻨﻭﻉ‬
‫‪ int32‬ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻴﻌﺘﺒﺭ ﺃﻜﺜﺭ ﺃﻨﻭﺍﻉ ﺍﻷﻋﺩﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ ﻓﻌﺎﻟﻴﺔ‪ .‬ﻋﻨﺩ ﺘﺤﻭﻴﻠﻙ ﻟﻨﻅﺎﻡ ﻜﺘﺏ‬
‫ﺒﻠﻐﺔ ﺍﻹﺼﺩﺍﺭ ﺍﻟﺴﺎﺩﺱ ﺇﻟﻰ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻗﻡ ﺒﺘﻐﻴﻴﺭ ﻜل ﺃﻨﻭﺍﻉ ‪ Long‬ﺇﻟﻰ ‪ Int32‬ﻟﺘﺤﺼل ﻋﻠﻰ‬
‫ﻨﻅﺎﻡ ﺃﻜﺜﺭ ﻓﻌﺎﻟﻴﺔ‪.‬‬
‫ﺍﻟﺴﻼﺴل ‪String‬‬
‫ﺘﻡ ﺍﺴﺘﺒﺩﺍل ﻜل ﺍﻟﺩﻭﺍل ﺍﻟﺘﻲ ﺘﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺴﻼﺴل ﻭ ﺍﻟﺘﻲ ﻜﺎﻨﺕ ﻤﻭﺠﻭﺩﺓ ﺒﺎﻻﺼﺩﺍﺭ ﺍﻟﺴﺎﺩﺱ ﻤﺜل‬
‫‪ Left,Right,Mid‬ﺒﻭﻅﺎﺌﻑ ﺠﺩﻴﺩﺓ ﺘﻨﺩﺭﺝ ﺘﺤﺕ ﺍﻟﻔﺌﺔ ‪ . System.Class‬ﺍﺭﺠﻊ ﺇﻟﻰ ﺍﻟﻔﺼل‬
‫ﺍﻟﺨﺎﺹ ﺒﺎﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺴﻼﺴل ﺍﻟﺤﺭﻓﻴﺔ‪.‬‬
‫ﺍﻟﻨﻭﻉ ﺍﻟﻤﺘﻌﺩﺩ ‪Variant‬‬

‫ﻜﺎﻥ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻴﺨﺩﻡ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻜﻨﻭﻉ ﺒﻴﺎﻨﺎﺕ ﻋﺎﻡ ‪ .‬ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻟﻡ ﻴﻌﺩ ﻫﺫﺍ ﺍﻟﻨﻭﻉ‬
‫ﻤﻭﺠﻭﺩﺍ ﻓﻘﺩ ﺘﻡ ﺍﺴﺘﺒﺩﺍﻟﻪ ﺒﻨﻭﻉ ‪ Object‬ﻟﻴﺅﺩﻱ ﻨﻔﺱ ﺍﻟﻤﻬﺎﻡ ﻭ ﻟﻴﺨﺩﻡ ﻜﻨﻭﻉ ﺒﻴﺎﻨﺎﺕ ﻋﺎﻡ‬
‫‪46‬‬
‫ﻓﺘﺭﺓ ﺤﻴﺎﺓ ﺍﻟﻤﺘﻐﻴﺭ ‪:‬‬

‫ﻴﻤﻜﻥ ﺘﻌﺭﻴﻑ ﻓﺘﺭﺓ ﺤﻴﺎﺓ ﺍﻟﻤﺘﻐﻴﺭ ﺒﺄﻨﻬﺎ ﺍﻟﻔﺘﺭﺓ ﺍﻟﺘﻲ ﻴﻅل ﻓﻴﻬﺎ ﺍﻟﻤﺘﻐﻴﺭ ﻤﺤﺘﻔﻅﺎ ﺒﻘﻴﻤﺘﻪ‪.‬‬
‫ﻤﻥ ﺍﻟﻤﻬﻡ ﺠﺩﺍ ﺃﻥ ﺘﺤﺩﺩ ﻟﻜل ﻤﺘﻐﻴﺭ ﻓﺘﺭﺓ ﺤﻴﺎﺘﻪ ﺤﺘﻰ ﻴﺘﺴﻨﻰ ﻟﻙ ﺘﻌﺭﻴﻔﻪ ﻓﻲ ﺍﻟﻤﺠﺎل ﺍﻟﻤﻨﺎﺴﺏ ﻟﻪ‬
‫ﻭﻟﻌﻠﻨﺎ ﻨﺫﻜﺭ ﻤﺜﺎﻟﻴﻥ ﻟﻤﺸﻜﻠﺘﻴﻥ ﺘﺤﺼﻼﻥ ﻋﻨﺩ ﻋﺩﻡ ﺍﻟﺩﻗﺔ ﻓﻲ ﺘﺤﺩﻴﺩ ﻤﺠﺎل ﺍﻟﻤﺘﻐﻴﺭ ‪:‬‬
‫‪ -١‬ﻀﻴﺎﻉ ﻗﻴﻡ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻤﻤﺎ ﻴﺅﺩﻱ ﺇﻟﻰ ﻋﺩﻡ ﺃﺩﺍﺀ ﺍﻟﻨﻅﺎﻡ ﻟﻠﻤﻬﺎﻡ ﺍﻟﻤﻁﻠﻭﺒﺔ ﻤﻨﻪ‪ ،‬ﻓﻌﻠﻰ ﺴﺒﻴل‬
‫ﺍﻟﻤﺜﺎل ﻟﻭ ﻋﺭﻓﺕ ﻤﺘﻐﻴﺭﺍ ﻋﻠﻰ ﺃﻨﻪ ﻤﺘﻐﻴﺭ ﻋﻠﻰ ﻤﺴﺘﻭﻯ ﺍﻻﺠﺭﺍﺀ ﻭ ﺃﺭﺩﺕ ﺃﻥ ﺘﺴﺘﺨﺩﻤﻪ ﻓﻲ‬
‫ﻤﻜﺎﻥ ﻤﺎ ﺨﺎﺭﺝ ﺍﻟﻤﺘﻐﻴﺭ ﻓﺈﻨﻙ ﻟﻥ ﺘﺠﺩ ﻗﻴﻤﺔ ﻫﺫﺍ ﺍﻟﻤﺘﻐﻴﺭ‪.‬‬
‫‪ -٢‬ﺘﻀﻴﻴﻊ ﻤﻭﺍﺭﺩ ﺍﻟﺫﺍﻜﺭﺓ ‪ :‬ﻗﺩ ﺘﺄﺘﻲ ﻓﻜﺭﺓ ﺇﻟﻰ ﺸﺨﺹ ﻤﺎ ﺒﺘﻌﺭﻴﻑ ﻜل ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺘﻌﺭﻴﻔﺎ ﻋﺎﻤﺎ‬
‫ﻋﻠﻰ ﻤﺴﺘﻭﻯ ﺍﻟﻨﻅﺎﻡ ﺤﺘﻰ ﻴﺘﺨﻠﺹ ﻤﻥ ﺍﻟﺘﻔﻜﻴﺭ ﺒﻤﺠﺎل ﻜل ﻤﺘﻐﻴﺭ‪ ،‬ﻫﺫﻩ ﺍﻟﻔﻜﺭﺓ ﻤﺭﻴﺤﺔ ﻟﻜﻨﻬﺎ‬
‫ﻀﺎﺭﺓ ﻷﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﻤﺔ ﺘﺴﺘﻬﻠﻙ ﻤﻭﺍﺭﺩ ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ‪.‬‬
‫ﻴﻭﺠﺩ ﺨﻤﺴﺔ ﺃﻨﻭﺍﻉ ﻤﻥ ﺍﻟﻔﺘﺭﺍﺕ ‪:‬‬

‫‪ -١‬ﺍﻟﻔﺘﺭﺓ ﺍﻟﺘﻲ ﺘﺒﺩﺃ ﻋﻨﺩ ﺒﺩﺀ ﺘﺸﻐﻴل ﺍﻟﺤل ﻭﺘﻨﺘﻬﻲ ﺒﻨﻬﺎﻴﺘﻪ ﻭ ﻫﻲ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﻤﺔ‪.‬‬
‫‪ -٢‬ﻓﺘﺭﺓ ﺘﺒﺩﺃ ﻋﻨﺩ ﺘﺸﻐﻴل ﻤﺸﺭﻭﻉ ﻤﺎ ﻭ ﺘﺸﻤل ﻜل ﻤﺎ ﻴﻨﺩﺭﺝ ﺘﺤﺕ ﻫﺫﺍ ﺍﻟﻤﺸﺭﻭﻉ ﻤﻥ ﺃﻨﻅﻤﺔ‬
‫ﺘﻁﺒﻴﻘﻴﺔ ﻭ ﻨﻤﺎﺫﺝ ﻭ ﻏﻴﺭﻫﺎ‪.‬‬
‫‪ -٣‬ﻓﺘﺭﺓ ﺘﺒﺩﺃ ﻋﻨﺩ ﺘﺸﻐﻴل ﻨﻤﻭﺫﺝ ﻭ ﻫﻲ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﻤﺔ ﻋﻠﻰ ﻤﺴﺘﻭﻯ ﺍﻟﻨﻤﻭﺫﺝ ﺃﻭ ﻤﻥ ﻨﻭﻉ‬
‫‪ Static‬ﻓﻲ ﺇﺠﺭﺍﺀ ﻤﺎ ﺩﺍﺨل ﺍﻟﻨﻤﻭﺫﺝ‪.‬‬
‫‪ -٤‬ﻓﺘﺭﺓ ﺘﺒﺩﺃ ﻋﻨﺩ ﺘﻨﻔﻴﺫ ﺍﻹﺠﺭﺍﺀ ﻭ ﺘﻨﺘﻬﻲ ﻗﻴﻡ ﺍﻟﻤﺘﻐﻴﺭ ﺒﺎﻨﺘﻬﺎﺀ ﺘﻨﻔﻴﺫ ﺍﻹﺠﺭﺍﺀ ﻭﻫﻲ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ‬
‫ﺍﻟﻤﺤﻠﻴﺔ ﺩﺍﺨل ﺍﻹﺠﺭﺍﺀ‪.‬‬
‫‪ -٥‬ﻓﺘﺭﺓ ﺘﺒﺩﺃ ﻋﻨﺩ ﺘﻨﻔﻴﺫ ﻤﻘﻁﻊ ﻤﻥ ﻜﻭﺩ ﻭ ﺘﻨﺘﻬﻲ ﺒﻨﻬﺎﻴﺘﻪ ﻭ ﻫﻲ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺤﻠﻴﺔ ﻋﻠﻰ‬
‫ﻤﺴﺘﻭﻯ ﻫﺫﺍ ﺍﻟﻤﻘﻁﻊ‪.‬‬
‫ﻤﺠﺎل ﺍﻟﻤﺘﻐﻴﺭﺍﺕ‬
‫ﺒﻌﺩ ﺘﺤﺩﻴﺩ ﺍﻟﻔﺘﺭﺓ ﺍﻟﺘﻲ ﺘﺭﻴﺩ ﺃﻥ ﻴﺒﻘﻰ ﻓﻴﻬﺎ ﺍﻟﻤﺘﻐﻴﺭ ﻤﺤﺘﻔﻅﺎ ﺒﻘﻴﻤﺘﻪ ﺘﺄﺘﻲ ﻤﺭﺤﻠﺔ ﺘﺤﺩﻴﺩ ﻤﺠﺎل ﻫﺫﺍ‬
‫ﺍﻟﻤﺘﻐﻴﺭ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‪.‬‬
‫‪ -١‬ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﻤﺔ ﺘﻌﺭﻑ ﺒﻜﻠﻤﺔ ‪ Public‬ﻭ ﺘﻜﻭﻥ ﻋﺎﻤﺔ ﻟﻜل ﺍﻟﻤﺸﺎﺭﻴﻊ ﺩﺍﺨل ﺍﻟﺤل‪.‬‬
‫‪47‬‬
‫‪ -٢‬ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻌﺎﻤﺔ ﺩﺍﺨل ﺍﻟﻤﺸﺭﻭﻉ ﻓﻘﻁ ﻴﻤﻜﻥ ﺘﻌﺭﻴﻔﻬﺎ ﻤﻥ ﺨﻼل ﻜﻠﻤﺔ ‪ Friend‬ﻭ ﺘﻜﻭﻥ‬
‫ﻋﺎﻤﺔ ﻟﻜل ﺍﻟﻨﻤﺎﺫﺝ ﻭ ﺍﻻﺠﺭﺍﺀﺍﺕ ﺩﺍﺨل ﺍﻟﻤﺸﺭﻭﻉ‪.‬‬
‫‪ -٣‬ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﺨﺎﺼﺔ ﺒﺎﻟﻨﻤﻭﺫﺝ ﺃﻭ ﺒﺎﻟﻨﻅﺎﻡ ﺍﻟﺘﻁﺒﻴﻘﻲ ﻭ ﻴﺘﻡ ﺘﻌﺭﻴﻔﻬﺎ ﻤﻥ ﺨﻼل ﻜﻠﻤﺔ ‪. Private‬‬
‫ﻻ ﺤﻅ ﺃﻨﻪ ﻻ ﻴﻤﻜﻥ ﺍﺴﺘﺨﺩﺍﻡ ﻫﺫﻩ ﺍﻟﻜﻠﻤﺔ ﺩﺍﺨل ﺍﺠﺭﺍﺀ ﻤﺎ‪.‬‬
‫‪ -٤‬ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﻤﺤﻠﻴﺔ ﻓﻲ ﺍﻻﺠﺭﺍﺀﺍﺕ ﻴﻤﻜﻥ ﺘﻌﺭﻴﻔﻬﺎ ﻤﻥ ﺨﻼل ﻜﻠﻤﺔ ‪ Dim‬ﻻﺤﻅ ﺃﻥ ﻗﻴﻡ ﻫﺫﻩ‬
‫ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺘﻨﺘﻬﻲ ﺒﻨﻬﺎﻴﺔ ﺍﻻﺠﺭﺍﺀ‪ .‬ﻴﻤﻜﻥ ﺘﻤﺩﻴﺩ ﺤﻴﺎﺓ ﻤﺘﻐﻴﺭ ﺩﺍﺨل ﺍﺠﺭﺍﺀ ﻭ ﺫﻟﻙ ﺒﺘﻌﺭﻴﻔﻪ‬
‫ﺒﻜﻠﻤﺔ ‪.Static‬‬
‫ﻤﺜﺎل ﻋﻠﻰ ﻤﺠﺎل ﺍﻟﻤﺘﻐﻴﺭ ‪Variable Scope‬‬

‫)(‪Sub Test1‬‬
‫ﳎﺎل اﻻﺟﺮاء ' ‪Dim L As Integer‬‬
‫‪If L = 5 Then‬‬
‫ﳎﺎل اﳌﻘﻄﻊ ' ‪Dim B As Integer‬‬
‫‪B = L‬‬
‫‪End If‬‬
‫‪End Sub‬‬
‫ﻓﻲ ﻫﺫﺍ ﺍﻟﻤﺜﺎل ﻴﻭﺠﺩ ﻨﻭﻋﻴﻥ ﻤﻥ ﺍﻟﻤﺠﺎﻻﺕ ‪:‬‬
‫‪ .I‬ﺍﻟﻤﺘﻐﻴﺭ ‪ L‬ﻫﻭ ﻤﺘﻐﻴﺭ ﻤﻌﺭﻑ ﻟﻤﺠﺎل ﺍﻻﺠﺭﺍﺀ ﻜﺎﻤﻼ‪.‬‬
‫‪ .II‬ﺍﻟﻤﺘﻐﻴﺭ ‪ B‬ﻫﻭ ﻤﺘﻐﻴﺭ ﻟﻤﻘﻁﻊ ﺠﻤﻠﺔ ‪ .If‬ﻟﻭ ﺤﺎﻭﻟﺕ ﻤﻌﺭﻓﺔ ﻗﻴﻤﺔ ‪ B‬ﻓﺈﻨﻙ ﻟﻥ ﺘﺴﺘﻁﻴﻊ ﺒﻌﺩ ﺍﻟﺠﻤﻠﺔ‬
‫‪ If‬ﻷﻥ ﺤﻴﺎﺘﻪ ﺘﻨﺘﻬﻲ ﺒﻨﻬﺎﻴﺔ ﻫﺫﻩ ﺍﻟﺠﻤﻠﺔ‪.‬‬
‫ﻁﺭﻕ ﻤﺘﻌﺩﺩﺓ ﻟﺘﻌﺭﻴﻑ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ‬
‫ﺃﻀﺎﻓﺕ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻁﺭﻗﺎ ﺠﺩﻴﺩﺓ ﺴﻬﻠﺕ ﺘﻌﺭﻴﻑ ﺍﻟﻤﺘﻐﻴﺭ‪ ،‬ﻟﻨﺄﺨﺫ ﻫﺫﻩ ﺍﻟﻁﺭﻕ ﻋﻠﻰ ﺸﻜل ﺃﻤﺜﻠﺔ‪.‬‬
‫‪ -١‬ﻋﺭﻑ ﻭ ﺃﺴﻨﺩ ﺍﻟﻘﻴﻤﺔ ﻓﻲ ﻨﻔﺱ ﺍﻟﺴﻁﺭ ‪:‬‬
‫‪Dim myVar As Integer = 9‬‬
‫‪ -٢‬ﺘﻌﺭﻴﻑ ﻋﺩﺓ ﻤﺘﻐﻴﺭﺍﺕ ‪:‬‬

‫‪Dim I, J As Integer‬‬
‫‪Dim L As Integer, M As Integer‬‬
‫‪Dim N As Integer, X As Double‬‬
‫‪48‬‬
‫ﻻﺤﻅ ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻷﻭل ﻜﻴﻑ ﻋﺭﻓﻨﺎ ﻤﺘﻐﻴﻴﺭ ﻤﻥ ﻨﻭﻉ ‪ Integer‬ﺒﺩﻭﻥ ﺍﻟﺤﺎﺠﺔ ﺇﻟﻰ ﺇﻋﺎﺩﺓ ﻜﻠﻤﺔ‬
‫‪ .Dim‬ﺜﻡ ﻻﺤﻅ ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻨﻲ ﻁﺭﻴﻘﺔ ﺃﺨﺭﻯ ﻟﻨﻔﺱ ﺍﻟﺘﻌﺭﻴﻑ‪ .‬ﺃﻤﺎ ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻟﺙ ﻓﻌﺭﻓﻨﺎ‬
‫ﻤﺘﻐﻴﺭﺍﺕ ﻤﺘﻌﺩﺩﺓ ﻤﻥ ﺃﻜﺜﺭ ﻤﻥ ﻨﻭﻉ ﻓﻲ ﻨﻔﺱ ﺍﻟﺴﻁﺭ‪.‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺠﻤﻠﺔ ﺍﻟﺘﻲ ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻷﻭل ﻓﻲ ﺍﻹﺼﺩﺍﺭ ﺍﻟﺴﺎﺩﺱ ﺒﺘﻌﺭﻴﻑ ﻤﺘﻐﻴﺭ ﻤﻥ ﻨﻭﻉ‬
‫‪ Variant‬ﻭ ﺁﺨﺭ ﻤﻥ ﻨﻭﻉ ‪ Integer‬ﻟﻜﻨﻬﺎ ﻓﻲ ﺍﻟﺩﻭﺕ ﻨﺕ ﺘﻌﺭﻑ ﻜﻼ ﺍﻟﻤﺘﻐﻴﺭﻴﻥ ﻤﻥ ﻨﻭﻉ‬
‫‪.Integer‬‬
‫‪ -٣‬ﺘﻌﺭﻴﻑ ﻤﺘﻐﻴﺭﺍﺕ ﻟﻠﻘﺭﺍﺀﺓ ﻓﻘﻁ ‪ :‬ﻭ ﻫﻭ ﻤﺎﻟﻡ ﻴﻜﻥ ﻤﻭﺠﻭﺩ ﻓﻲ ﺍﻻﺼﺩﺍﺭ ﺍﻟﺴﺎﺩﺱ ﻭ ﺇﻟﻴﻙ ﻫﺫﺍ‬
‫ﺍﻟﻤﺜﺎل ‪:‬‬
‫‪ReadOnly x As Integer‬‬
‫ﻋﻨﺩ ﺘﻌﺭﻴﻑ ﻤﺘﻐﻴﺭ ﻟﻠﻘﺭﺍﺀﺓ ﻻ ﻴﻤﻜﻥ ﺘﻌﺭﻴﻔﻪ ﻤﺤﻠﻴﺎ ﺩﺍﺨل ﺍﺠﺭﺍﺀ ﺒل ﻴﻠﺯﻡ ﺘﻌﺭﻴﻔﻪ ﻋﻠﻰ ﻤﺴﺘﻭﻯ‬
‫ﺍﻟﻨﻤﻭﺫﺝ ‪.‬‬
‫ﻀﻭﺍﺒﻁ ﺘﺴﻤﻴﺔ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ‬
‫ﺘﻌﺭﻑ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﺸﺭﻭﻁ ﻟﺘﺴﻤﻴﺔ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺍﻟﺘﻲ ﻴﺠﺏ ﺍﻟﺘﻘﻴﺩ ﺒﻬﺎ ﻭ ﺇﻻ ﻓﺈﻥ ﺒﻴﺌﺔ‬
‫ﺍﻟﺩﻭﺕ ﻨﺕ ﺴﻭﻑ ﻟﻥ ﺘﻘﺒل ﺘﻌﺭﻴﻑ ﺍﻟﻤﺘﻐﻴﺭ ﺍﻟﻤﺨﺎﻟﻑ ﻟﻬﺫﻩ ﺍﻟﻀﻭﺍﺒﻁ‪ ،‬ﻭﻫﺫﻩ ﺍﻟﻀﻭﺍﺒﻁ ﻫﻲ ‪:‬‬
‫‪ -١‬ﺃﻥ ﺘﺒﺩﺃ ﺃﺴﻤﺎﺀ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﺒﺤﺭﻑ ﺃﺒﺠﺩﻱ‪.‬‬
‫‪ -٢‬ﺃﻥ ﻴﻜﻭﻥ ﻁﻭل ﺍﺴﻡ ﺍﻟﻤﺘﻐﻴﺭ ﺒﻴﻥ ﺤﺭﻑ ﻭ ﺍﺤﺩ ﻭ ‪ ٢٥٥‬ﺤﺭﻑ‪.‬‬
‫‪ -٣‬ﻻ ﻴﺴﻤﺢ ﺃﻥ ﻴﻜﻭﻥ ﺍﺴﻡ ﺍﻟﻤﺘﻐﻴﺭ ﻜﻠﻤﺔ ﻤﺤﺠﻭﺯﺓ ﻤﻥ ﻗﺒل ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‪.‬‬
‫‪ -٤‬ﺃﻥ ﻴﺘﻜﻭﻥ ﺍﺴﻡ ﺍﻟﻤﺘﻐﻴﺭ ﻤﻥ ﺤﺭﻭﻑ ﻭﻴﻤﻜﻥ ﺃﻥ ﺘﺩﺨل ﺒﻌﺽ ﺍﻷﺭﻗﺎﻡ ﻓﻲ ﺍﻟﺘﺴﻤﻴﺔ ﻭ ﻜﺫﻟﻙ‬
‫ﺍﻟﺸﺭﻁﺔ ﺍﻟﺴﻔﻠﻴﺔ‪ ،‬ﺃﻤﺎ ﻏﻴﺭ ﺫﻟﻙ ﻤﻥ ﺍﻟﺭﻤﻭﺯ ﻓﻐﻴﺭ ﻤﺴﻤﻭﺡ ﺩﺨﻭﻟﻬﺎ ﻓﻲ ﺍﻻﺴﻡ‪.‬‬
‫ﺴﺒﺏ ﺍﻟﻤﺨﺎﻟﻔﺔ‬ ‫ﺍﺴﻡ ﺍﻟﻤﺘﻐﻴﺭ‬
‫ﺍﺴﻡ ﻤﺤﺠﻭﺯ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‬ ‫‪Class‬‬
‫& ﻋﻼﻤﺔ ﻏﻴﺭ ﻤﺴﻤﻭﺡ ﺒﺎﺴﺘﺨﺩﺍﻤﻬﺎ‬ ‫‪Phone&Number‬‬
‫ﻏﻴﺭ ﻤﺴﻤﻭﺡ ﺃﻥ ﻴﺒﺩﺃ ﺍﻻﺴﻡ ﺒﺭﻗﻡ‬ ‫‪18Width‬‬
‫ﺍﻟﻤﺴﺎﻓﺔ ﻏﻴﺭ ﻤﺴﻤﻭﺡ ﺒﺄﻥ ﺘﺩﺨل ﻓﻲ ﺍﺴﻡ ﺍﻟﻤﺘﻐﻴﺭ‬ ‫‪First Name‬‬
‫ﺘﻌﻴﻴﻥ ﻗﻴﻡ ﻟﻠﻤﺘﻐﻴﺭﺍﺕ‬
‫‪49‬‬
‫ﺍﻟﺼﻴﻐﺔ ﺍﻟﻌﺎﻤﺔ ﻟﺘﻌﻴﻴﻥ ﻗﻴﻤﺔ ﻟﻤﺘﻐﻴﺭ ﻤﺎ ﻫﻲ ﺍﻟﺼﻴﻐﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫‪Var=Value‬‬
‫ﺘﻼﺤﻅ ﺃﻨﻨﺎ ﺒﺩﺃﻨﺎ ﺒﺎﺴﻡ ﺍﻟﻤﺘﻐﻴﺭ ﺜﻡ ﻭﻀﻌﻨﺎ ﻋﻼﻤﺔ = ﺜﻡ ﻭﻀﻌﻨﺎ ﻗﻴﻤﺔ ﺍﻟﻤﺘﻐﻴﺭ ﻫﺫﻩ ﺍﻟﻘﻴﻤﺔ ﻗﺩ ﺘﻜﻭﻥ ﻗﻴﻤﺔ‬
‫ﺃﻨﺕ ﺘﻘﻭﻡ ﺒﺎﻋﻁﺎﺌﻬﺎ ﻟﻠﻤﺘﻐﻴﺭ ﺃﻭ ﻗﺩ ﺘﻜﻭﻥ ﺨﺎﺼﻴﺔ ﺃﺤﺩ ﺍﻷﺩﻭﺍﺕ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‪.‬‬
‫ﺴﻭﻑ ﻨﺄﺨﺫ ﺜﻼﺜﺔ ﺃﻤﺜﻠﺔ ﻟﺘﺭﻯ ﻜﻴﻑ ﺘﻘﻭﻡ ﺒﺘﻌﻴﻴﻥ ﻗﻴﻡ ﻟﻬﺎ‪.‬‬
‫ﺍﻟﻤﺜﺎل ﺍﻷﻭل‬
‫‪Dim NumberOfStudent as integer‬‬
‫‪NumberOfStudent =15‬‬
‫ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﻗﻤﻨﺎ ﺒﻤﺎ ﻴﻠﻲ ‪:‬‬
‫‪ -١‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻷﻭل ﻋﺭﻓﻨﺎ ﻤﺘﻐﻴﺭ ﻤﻥ ﻨﻭﻉ ﻋﺩﺩ ﺼﺤﻴﺢ ‪.‬‬
‫‪ -٢‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻨﻲ ﻋﻴﻨﺎ ﻗﻴﻤﺔ ﻟﻬﺫﺍ ﺍﻟﻤﺘﻐﻴﺭ ﻭﻫﻲ ‪.١٥‬‬
‫ﺍﻟﻤﺜﺎل ﺍﻟﺜﺎﻨﻲ‬
‫‪Dim Name as String‬‬
‫”‪Name=”Khalid‬‬
‫‪ -١‬ﻋﺭﻓﻨﺎ ﻤﺘﻐﻴﺭ ﻤﻥ ﻨﻭﻉ ﺴﻠﺴﻠﺔ ﺤﺭﻓﻴﺔ‪.‬‬
‫‪ -٢‬ﻗﻤﻨﺎ ﺒﺘﻌﻴﻴﻥ ﻗﻴﻤﺔ ‪ Khalid‬ﻟﻬﺫﺍ ﺍﻟﻤﺘﻐﻴﺭ‪ .‬ﻻﺤﻅ ﺃﻨﻪ ﻋﻨﺩ ﺘﻌﻴﻴﻥ ﻗﻴﻡ ﺍﻟﺴﻼﺴل ﺍﻟﺤﺭﻓﻴﺔ ﻻﺒﺩ ﻤﻥ‬
‫ﻭﻀﻊ ﻗﻴﻤﻬﺎ ﺒﻴﻥ ﻋﻼﻤﺘﻲ ﺘﻨﺼﻴﺹ‪.‬‬
‫ﺍﻟﻤﺜﺎل ﺍﻟﺜﺎﻟﺙ‬
‫‪Dim Result as Boolean‬‬
‫‪Result=True‬‬
‫‪ -١‬ﻋﺭﻓﻨﺎ ﻤﺘﻐﻴﺭ ﻤﻥ ﻨﻭﻉ ‪.Boolean‬‬
‫‪ -٢‬ﻗﻤﻨﺎ ﺒﺈﺴﻨﺎﺩ ﻗﻴﻤﺔ ﺼﺢ ﻟﻬﺫﺍ ﺍﻟﻤﺘﻐﻴﺭ ﻷﻨﻬﺎ ﺃﺤﺩ ﺍﻟﻘﻴﻤﺘﻴﻥ ﺍﻟﻤﺴﻤﻭﺤﺘﻴﻥ ﻟﻪ‪.‬‬
‫ﺘﻌﻴﻴﻥ ﻗﻴﻤﺔ ﻤﺘﻐﻴﺭ ﻵﺨﺭ ﺃﻭ ﻟﺨﺎﺼﻴﺔ ﺃﺩﺍﺓ‬
‫‪50‬‬
‫ﻴﻤﻜﻥ ﺃﻥ ﺘﺴﻨﺩ ﻗﻴﻤﺔ ﻤﺘﻐﻴﺭ ﺇﻟﻰ ﻤﺘﻐﻴﺭ ﺁﺨﺭ ﻜﻤﺎ ﻴﻭﻀﺢ ﺫﻟﻙ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ‬
‫‪Dim a As Integer = 5‬‬
‫‪Dim b As Integer‬‬
‫‪b = a‬‬
‫‪ -١‬ﻋﺭﻓﻨﺎ ﻤﺘﻐﻴﺭ ‪ a‬ﻤﻥ ﻨﻭﻉ ‪ Integer‬ﻭ ﻋﻴﻨﺎ ﻟﻪ ﻗﻴﻤﺔ ‪.٥‬‬
‫‪ -٢‬ﻋﺭﻓﻨﺎ ﻤﺘﻐﻴﺭ ‪ b‬ﻤﻥ ﻨﻭﻉ ‪.Integer‬‬
‫‪ -٣‬ﻗﻤﻨﺎ ﺒﺘﻌﻴﻴﻥ ﻗﻴﻤﺔ ﻟﻠﻤﺘﻐﻴﺭ ‪ b‬ﻭﻫﻲ ﻗﻴﻤﺔ ﺍﻟﻤﺘﻐﻴﺭ ‪ a‬ﻭﻫﻲ ‪.٥‬‬
‫ﺃﻥ ﺘﺴﻨﺩ ﻗﻴﻤﺔ ﺨﺎﺼﻴﺔ ﺃﺩﺍﺓ ﻤﺎ ﻟﻤﺘﻐﻴﺭ ﻜﻤﺎ ﻴﻭﻀﺢ ﺫﻟﻙ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ‬
‫‪Dim a As String‬‬
‫‪a = TextBox1.Text‬‬
‫‪ -١‬ﻋﺭﻓﻨﺎ ﻤﺘﻐﻴﺭ ‪ a‬ﻤﻥ ﻨﻭﻉ ‪.Integer‬‬
‫‪ -٢‬ﻗﻤﻨﺎ ﺒﺘﻌﻴﻴﻥ ﻗﻴﻤﺔ ﻟﻠﻤﺘﻐﻴﺭ ‪ a‬ﻭﻫﻲ ﻤﺎ ﺘﺤﺘﻭﻴﻪ ﺨﺎﺼﻴﺔ ‪ Text‬ﻭﻫﻲ ﺃﺤﺩ ﺨﺼﺎﺌﺹ ﺍﻷﺩﺍﺓ‬
‫‪.TextBox1‬‬
‫ﺍﺴﺘﺨﺩﺍﻡ ﺨﻴﺎﺭ‪Explicit‬‬
‫ﻤﺭ ﺒﻙ ﻓﻲ ﺍﻟﺴﺎﺒﻕ ﺃﻨﻪ ﻻﺒﺩ ﻤﻥ ﺘﻌﺭﻴﻑ ﺃﻱ ﻤﺘﻐﻴﺭ ﻗﺒل ﺍﺴﺘﺨﺩﺍﻤﻪ‪ ،‬ﻟﻜﻥ ﻤﺎﺫﺍ ﺇﺫﺍ ﺭﻏﺒﺕ ﺒﻜﺴﺭ ﻫﺫﻩ‬
‫ﺍﻟﻘﺎﻋﺩﺓ ﻟﻅﺭﻑ ﻤﻥ ﺍﻟﻅﺭﻭﻑ‪ .‬ﺘﻘﻭﻡ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﺒﻤﻨﺤﻙ ﺨﻴﺎﺭ ‪ Explicit‬ﻭ ﺍﻟﺫﻱ ﻴﺤﺩﺩ ﻤﺎ ﺇﺫﺍ ﻜﺎﻥ‬
‫ﺘﻌﺭﻴﻑ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻀﺭﻭﺭﻴﺎ ﺃﻭ ﻻ‪ .‬ﻴﺤﻤل ‪ Explicit‬ﻗﻴﻤﺘﻴﻥ ﻫﻤﺎ ‪ On‬ﻭ ‪ .Off‬ﺍﻟﻘﻴﻤﺔ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ‬
‫ﻫﻲ ‪ On‬ﺒﻤﻌﻨﻰ ﺃﻨﻪ ﻴﺠﺏ ﻋﻠﻴﻙ ﺘﻌﺭﻴﻑ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ‪ ،‬ﻓﻲ ﺤﺎل ﺭﻏﺒﺕ ﺒﻌﺩﻡ ﺘﻌﺭﻴﻑ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ ﻗﻡ‬
‫ﺒﺘﻐﻴﻴﺭﻫﺎ ﺇﻟﻰ ‪ Off‬ﻜﻤﺎ ﻴﺘﻀﺢ ﻤﻥ ﺍﻟﺸﻜل)‪ .(١-٣‬ﻻﺤﻅ ﺃﻥ ﺠﻤﻠﺔ ﺍﻟﺘﻐﻴﻴﺭ ﻻﺒﺩ ﺃﻥ ﺘﻜﻭﻥ ﻓﻲ ﺃﻭل‬
‫ﺸﻜل ‪ : ١ -٣‬ﺍﺴﺘﺨﺩﺍﻡ ﻋﺒﺎﺭﺓ ‪Option Explicit‬‬ ‫ﺴﻁﺭ‪.‬‬
‫‪51‬‬
‫ﺍﻟﺜﻭﺍﺒﺕ ‪Constants‬‬
‫ﻥ ﻫﺫﻩ ﺍﻟﻘﻴﻤﺔ ﻻ ﻴﻤﻜﻥ‬
‫ﻫﺫﺍ ﻨﻭﻉ ﻤﻥ ﻤﺨﺎﺯﻥ ﺍﻟﺫﺍﻜﺭﺓ‪ ،‬ﺘﻭﻀﻊ ﻓﻴﻪ ﻗﻴﻤﺔ‪ ،‬ﺘﻤﺎﻤﺎ ﻜﺎﻟﻤﺘﻐﻴ‪‬ﺭﺍﺕ‪ ،‬ﻭﻟﻜ ‪‬‬
‫ﺘﻐﻴﻴﺭﻫﺎ ﺒﻌﺩ ﺫﻟﻙ‪ ،‬ﻭﻫﺫﻩ ﻁﺭﻴﻘﺔ ﺘﻌﺭﻴﻔﻬﺎ‪:‬‬
‫‪Const MyConst = 3‬‬
‫ﺘﻭﺠﺩ ﻋﺩﺓ ﻓﻭﺍﺌﺩ ﻟﺘﻌﺭﻴﻑ ﺍﻟﺜﻭﺍﺒﺕ ‪:‬‬

‫‪ -١‬ﻴﻌﺘﺒﺭ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺜﻭﺍﺒﺕ ﺃﺴﺭﻉ ﻓﻲ ﺍﻟﺘﻨﻔﻴﺫ ﻤﻥ ﺍﻟﻤﺘﻐﻴﺭﺍﺕ‪.‬‬
‫‪ -٢‬ﺴﻬﻭﻟﺔ ﺘﻐﻴﻴﺭ ﺍﻟﺜﻭﺍﺒﺕ‪ ،‬ﺤﻴﺙ ﻟﻭ ﺍﻓﺘﺭﻀﻨﺎ ﺃﻨﻙ ﺘﺴﺘﻌﻤل ‪ MyConst‬ﺒﺸﻜل ﻜﺒﻴﺭ ﻓﻲ ﺍﻟﻨﻅﺎﻡ‬
‫ﻭ ﺃﺭﺩﺕ ﻟﺴﺒﺏ ﻤﺎ ﺘﻐﻴﻴﺭ ﻗﻴﻤﺘﻪ ﻓﺈﻨﻙ ﻟﻥ ﺘﺘﻌﺏ ﻓﻲ ﺫﻟﻙ ﺤﻴﺙ ﻴﻤﻜﻨﻙ ﺘﻐﻴﻴﺭ ﻫﺫﻩ ﺍﻟﻘﻴﻤﺔ ﻤﺭﺓ‬
‫ﻭﺍﺤﺩﺓ‪.‬‬
‫‪52‬‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺴﻼﺴل ﻭ ﺍﻟﻨﺼﻭﺹ‬

‫ﻴﻤﻜﻥ ﺘﻌﺭﻴﻑ ﺍﻟﺴﻼﺴل ﺍﻟﺤﺭﻓﻴﺔ ﺒﺄﻨﻬﺎ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﺤﺭﻭﻑ ﺃﻭ ﺍﻷﺭﻗﺎﻡ ﺃﻭ ﺨﻠﻴﻁ ﻤﻨﻬﻤﺎ‬
‫ﺃﻭﻤﻥ ﺃﻱ ﻨﻭﻉ ﺁﺨﺭ ﻤﻥ ﺍﻟﺭﻤﻭﺯ ﻟﻜﻥ ﺒﺸﺭﻁ ﺃﻥ ﻴﺘﻡ ﺘﻌﺭﻴﻔﻪ ﺒﺄﻨﻪ ﻤﻥ ﻨﻭﻉ ‪. String‬‬
‫ﺨﺫ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻋﻠﻰ ﺴﻼﺴل ﺤﺭﻓﻴﺔ ﻤﻌﺭﻓﺔ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‪.‬‬
‫‪Dim Name As String‬‬
‫‪Dim HouseNumber As String‬‬
‫"أﲪﺪ" = ‪Name‬‬
‫"‪HouseNumber = "12345‬‬
‫ﻓﻲ ﺍﻟﺒﺩﺍﻴﺔ ﻋﺭﻓﻨﺎ ﺴﻠﺴﻠﺘﻴﻥ ﺤﺭﻓﻴﺘﻴﻥ ﺍﻷﻭﻟﻰ ‪ Name‬ﻭ ﺍﻟﺜﺎﻨﻴﺔ ‪ HouseNumber‬ﺜﻡ ﻋﻴﻨﺎ‬
‫ﻗﻴﻤﺔ ﺃﺤﻤﺩ ﺇﻟﻰ ﺍﻟﺴﻠﺴﻠﺔ ‪ Name‬ﻭ ﻗﻴﻤﺔ ‪ ١٢٣٤٥‬ﺇﻟﻰ ﺍﻟﺴﻠﺴﻠﺔ ‪.HouseNumber‬‬
‫ﻋﻨﺩ ﺘﻌﺭﻴﻑ ﺍﻟﺴﻼﺴل ﻻﺒﺩ ﻤﻥ ﻭﻀﻌﻬﺎ ﺒﻴﻥ ﻋﻼﻤﺘﻲ ﺘﻨﺼﻴﺹ ﻜﻤﺎ ﻤﺭ ﻓﻲ ﺍﻟﻤﺜﺎل‪.‬‬
‫ﺘﻘﺩﻡ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻤﺠﻤﻭﻋﺔ ﻜﺒﻴﺭﺓ ﻤﻥ ﺍﻟﺩﻭﺍل ﺍﻟﺘﻲ ﺘﺴﻬل ﻋﻠﻴﻙ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺴﻼﺴل‬
‫ﺍﻟﺤﺭﻓﻴﺔ ﻭ ﺍﻟﻨﺼﻭﺹ‪ .‬ﺘﺼﻭﺭ ﺃﻥ ﻟﺩﻴﻙ ﻨﺹ ﻭ ﺘﺭﻴﺩ ﺃﻥ ﺘﻘﺘﻁﻊ ﺠﺯﺀ ﻤﻨﻪ ﺃﻭ ﺘﺒﺤﺙ ﻓﻴﻪ ﻋﻥ ﻨﺹ ﻤﺎ‪،‬‬
‫ﺇﻟﻰ ﻏﻴﺭ ﺫﻟﻙ ﻤﻥ ﺍﻟﻌﻤﻠﻴﺎﺕ ﺍﻟﺘﻲ ﻻ ﺘﻨﺘﻬﻲ ﻓﻬل ﺴﺘﻜﺘﺏ ﺒﺭﻨﺎﻤﺠﺎ ﺨﺎﺼﺎ ﻟﺘﻠﻙ ﺍﻟﻤﻬﺎﻡ ﺃﻡ ﻤﺎﺫﺍ ﺴﺘﻔﻌل‪.‬‬
‫ﺤﺎﺼل ﺍﻟﻘﻭل ﺃﻥ ﻫﻨﺎﻙ ﻋﺩﺩ ﻜﺒﻴﺭﺍ ﻤﻥ ﺍﻟﺩﻭﺍل ﺴﻭﻑ ﺘﺴﻬل ﻋﻠﻴﻙ ﺍﻟﺒﺭﻤﺠﺔ ﺒﺸﻜل ﻟﻡ ﻴﺴﺒﻕ ﻟﻪ ﻤﺜﻴل‪.‬‬
‫ﻤﻘﺎﺭﻨﺔ ﺍﻟﺴﻼﺴل‬
‫ﺇﺫﺍ ﺃﺭﺩﺕ ﻤﻘﺎﺭﻨﺔ ﺴﻠﺴﻠﺘﻴﻥ ﻟﺘﻜﺘﺸﻑ ﻫل ﻫﻤﺎ ﻤﺘﺴﺎﻭﻴﺘﺎﻥ ﻓﻲ ﺍﻟﻤﺤﺘﻭﻯ ﺃﻡ ﻻ ﺍﺴﺘﺨﺩﻡ ﺍﻟﺩﺍﻟﺔ‬
‫‪ . Compare‬ﻋﻠﻰ ﺴﺒﻴل ﺍﻟﻤﺜﺎل ‪:‬‬
‫"‪Dim str1 As String = "B‬‬
‫"‪Dim str2 As String = "A‬‬
‫ﺍﻟﺩﺍﻟﺔ ‪ str1‬ﺃﻜﺒﺭ ﺍﻟﺩﺍﻟﺔ ‪ str2‬ﻷﻥ ﻤﺤﺘﻭﻯ ﺍﻟﺴﻠﺴﻠﺔ ﺍﻷﻭﻟﻰ ‪ B‬ﺒﻴﻨﻤﺎ ﻤﺤﺘﻭﻯ ﺍﻟﺴﻠﺴﻠﺔ ﺍﻟﺜﺎﻨﻴﺔ ‪ A‬ﻭﻜﻤﺎ‬
‫ﺘﻌﺭﻑ ﻓﺈﻥ ﺍﻟﺤﺭﻑ ‪ B‬ﻴﺄﺘﻲ ﺒﻌﺩ ﺍﻟﺤﺭﻑ ‪ A‬ﻟﺫﻟﻙ ﺴﻭﻑ ﺘﻜﻭﻥ ﻨﺘﻴﺠﺔ ﺍﻟﻤﻘﺎﺭﻨﺔ ‪ .١‬ﻓﻲ ﺍﻟﺠﺎﻨﺏ ﺍﻟﻤﻘﺎﺒل‬
‫ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫"‪Dim str1 As String = "AA‬‬
‫ﺃﻤﺎ ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﻓﺈﻥ ﺍﻟﺴﻠﺴﻠﺔ ‪ str1‬ﺘﺴﺎﻭﻱ ﺍﻟﺴﻠﺴﻠﺔ ‪. str2‬‬
‫‪54‬‬
‫ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﻴﺢ ﻜﻴﻔﻴﺔ ﻤﻘﺎﺭﻨﺔ ﺴﻠﺴﻠﺘﻴﻥ ‪:‬‬

‫‪ -١‬ﻗﻡ ﺒﺘﻌﺭﻴﻑ ﺴﻠﺴﻠﺘﻴﻥ ﻭﻋﻴﻥ ﻟﻬﻤﺎ ﻨﻔﺱ ﺍﻟﻘﻴﻤﺔ ﻜﻤﺎ ﻴﻅﻬﺭ ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ‪.‬‬
‫‪ -٢‬ﻋﺭﻑ ﻤﺘﻐﻴﺭ ﻤﻥ ﻨﻭﻉ ‪.Integer‬‬
‫‪ -٣‬ﺍﺴﺘﺨﺩﻡ ﺍﻟﺩﺍﻟﺔ ‪ Compare‬ﻟﻤﻘﺎﺭﻨﺔ ﺍﻟﺴﻠﺴﻠﺘﻴﻥ ﺜﻡ ﺍﺭﺠﻊ ﻨﺘﻴﺠﺔ ﺍﻟﻤﻘﺎﺭﻨﺔ ﺇﻟﻰ ﺍﻟﻤﺘﻐﻴﺭ ‪.res‬‬
‫‪ -٤‬ﺍﻋﺭﺽ ﻨﺘﻴﺠﺔ ﺍﻟﻤﻘﺎﺭﻨﺔ ﻋﻠﻰ ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ‪.‬‬
‫‪Dim res As Integer‬‬
‫)‪res= String.Compare(str1, str2‬‬
‫)(‪:" + res.ToString‬ﻧﺘﻴﺠﺔ اﳌﻘﺎرﻧﺔ" = ‪Label1.Text‬‬
‫ﻟﻤﻌﺭﻓﺔ ﻨﺘﻴﺠﺔ ﺍﻟﻤﻘﺎﺭﻨﺔ ﺍﺭﺠﻊ ﺇﻟﻰ ﺍﻟﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫ﺍﻟﻤﻌﻨﻰ‬ ‫ﺍﻟﻨﺘﻴﺠﺔ‬
‫ﺍﻟﺴﻠﺴﻠﺔ ﺍﻷﻭﻟﻰ ﺃﻗل ﻤﻥ ﺍﻟﺜﺎﻨﻴﺔ‬ ‫ﺃﻗل ﻤﻥ ﺼﻔﺭ‬

‫ﺍﻟﺴﻠﺴﻠﺘﺎﻥ ﻤﺘﺴﺎﻭﻴﺘﺎﻥ‬ ‫ﺼﻔﺭ‬
‫ﺍﻟﺴﻠﺴﻠﺔ ﺍﻷﻭﻟﻰ ﺃﻜﺒﺭ ﻤﻥ ﺍﻟﺜﺎﻨﻴﺔ‬ ‫ﺃﻜﺒﺭ ﻤﻥ ﺼﻔﺭ‬
‫ﺩﻤﺞ ﺴﻠﺴﻠﺘﻴﻥ‬
‫ﻤﺎﺫﺍ ﻟﻭ ﻜﺎﻥ ﻫﻨﺎﻙ ﺴﻠﺴﻠﺘﻴﻥ ﻭ ﺃﺭﺩﺕ ﺃﻥ ﺘﺩﻤﺞ ﺍﻟﺴﻠﺴﻠﺘﻴﻥ ﺒﻤﻌﻨﻰ ﺃﻥ ﺘﻨﺘﺞ ﺴﻠﺴﻠﺔ ﺃﺨﺭﻯ ﺘﺤﻭﻱ ﺍﻟﺴﻠﺴﺔ‬
‫ﺍﻷﻭﻟﻰ ﻤﺘﺒﻭﻋﺔ ﺒﺎﻟﺴﻠﺴﻠﺔ ﺍﻟﺜﺎﻨﻴﺔ‪.‬‬
‫ﻟﻨﺄﺨﺫ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﺍﻟﺫﻱ ﻴﻭﻀﺢ ﻜﻴﻔﻴﺔ ﺩﻤﺞ ﺴﻠﺴﻠﺘﻴﻥ ‪:‬‬

‫"‪Dim FirstName As String = "Khalid‬‬
‫"‪Dim LastName As String = "AL-Jduaia‬‬
‫ﻓﻲ ﻫﺫﺍ ﺍﻟﻤﺜﺎل ﻻﺤﻅ ﺃﻨﻨﺎ ﺒﻬﺩﻑ ﺘﻜﻭﻴﻥ ﺍﺴﻡ ﻜﺎﻤل ﻓﺴﻭﻑ ﻨﻘﻭﻡ ﺒﺩﻤﺞ ﺍﻟﺴﻠﺴﻠﺘﻴﻥ ‪ FirstName‬ﻭ‬
‫‪ .LastName‬ﻜل ﻤﺎ ﻨﺤﺘﺎﺠﻪ ﻫﻭ ﺨﻁﻭﺓ ﻭﺍﺤﺩﺓ ﻓﻘﻁ ﻭﻫﻲ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺩﺍﻟﺔ ‪ . Concat‬ﻭﺍﻟﺘﻲ ﺘﻘﻭﻡ‬
‫ﺒﺈﺭﺠﺎﻉ ﻨﺘﻴﺠﺔ ﺩﻤﺞ ﺍﻟﺴﻠﺴﻠﺘﻴﻥ‪.‬‬
‫‪55‬‬
‫)‪Label1.Text = String.Concat(FirstName, LastName‬‬

‫ﺒﻌﺩ ﺩﻤﺞ ﺍﻟﺴﻠﺴﻠﺔ ﺍﻷﻭﻟﻰ ﻤﻊ ﺍﻟﺴﻠﺴﻠﺔ ﺍﻟﺜﺎﻨﻴﺔ ﻗﻤﻨﺎ ﺒﻌﺭﺽ ﻨﺘﻴﺠﺔ ﺍﻟﺩﻤﺞ ﻋﻠﻰ ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ‪.‬‬
‫ﺒﻌﺩ ﺩﻤﺞ ﺴﻠﺴﻠﺘﻴﻥ ﺘﻅل ﻗﻴﻤﻬﻤﺎ ﺒﺩﻭﻥ ﺃﻱ ﺘﻐﻴﺭ ﻤﺎﻟﻡ ﺘﻘﻡ ﺒﺫﻟﻙ‪.‬‬
‫ﺇﻀﺎﻓﺔ ﺤﺭﻭﻑ ﺇﻟﻰ ﺴﻠﺴﻠﺔ‬

‫ﻤﺎﺫﺍ ﻟﻭ ﺃﺭﺩﺕ ﺃﻥ ﺘﻀﻴﻑ ﺒﻌﺽ ﺍﻟﺤﺭﻭﻑ ﺃﻭ ﺍﻷﺭﻗﺎﻡ ﺃﻭ ﺍﻟﺭﻤﻭﺯ ﺇﻟﻰ ﺴﻠﺴﻠﺔ ﻤﺎ‪ .‬ﻻ ﻨﻘﺼﺩ ﺒﻌﻤﻠﻴﺔ‬
‫ﺍﻹﻀﺎﻓﺔ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﺤﺴﺎﺒﻴﺔ ﻟﻜﻥ ﻨﻘﺼﺩ ﻋﻤﻠﻴﺔ ﺇﺩﺭﺍﺝ ﻟﺤﺭﻭﻑ ﺃﺨﺭﻯ ﻟﺘﻜﻭﻥ ﻀﻤﻥ ﺍﻟﺴﻠﺴﻠﺔ‪.‬‬
‫ﻹﻀﺎﻓﺔ ﺤﺭﻭﻑ ﺇﻟﻰ ﺴﻠﺴﻠﺔ ﻗﻡ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﺩﺍﻟﺔ ‪.Insert‬‬
‫ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﻜﻴﻔﻴﺔ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺩﺍﻟﺔ ‪:Insert‬‬

‫”‪Dim str1 As String = “Saat‬‬
‫‪Dim strRes As String‬‬
‫)"‪strRes = str1.Insert(2, "lam‬‬
‫)(‪Label1.Text = strRes.ToString‬‬

‫‪ -١‬ﻋﺭﻓﻨﺎ ﺴﻠﺴﻠﺔ ﻭ ﻋﻴﻨﺎ ﻟﻬﺎ ﺍﻟﻘﻴﻤﺔ ‪.saat‬‬
‫‪ -٢‬ﻋﺭﻓﻨﺎ ﺴﻠﺴﻠﺔ ﺃﺨﺭﻯ ﻭﻟﻡ ﻨﺴﻨﺩ ﻟﻬﺎ ﺃﻱ ﻗﻴﻤﺔ‪.‬‬
‫‪ -٣‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻟﺙ ﻗﻤﻨﺎ ﺒﺘﻨﻔﻴﺫ ﺍﻟﺩﺍﻟﺔ ‪ Insert‬ﻭ ﺍﻟﺘﻲ ﺘﻘﻭﻡ ﺒﺈﻀﺎﻓﺔ ﺍﻟﻤﻘﻁﻊ ‪ lam‬ﺇﻟﻰ ﺍﻟﺴﻠﺴﻠﺔ‬
‫‪ str1‬ﺒﺩﺃ ﻤﻥ ﺍﻟﺤﺭﻑ ﺍﻟﺜﺎﻨﻲ ﺜﻡ ﺃﺭﺠﻌﻨﺎ ﻨﺎﺘﺞ ﺍﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺍﻟﺴﻠﺴﻠﺔ ‪ strRes‬ﻟﻴﺼﺒﺢ ﺍﻟﻨﺎﺘﺞ‬
‫ﻫﻭ ‪.Salamat‬‬
‫ﺘﺫﻜﺭ ﺃﻥ ﺍﻟﻔﻬﺭﺱ ﻓﻲ ﺍﻟﺩﻭﺕ ﻨﺕ ﻴﺒﺩﺃ ﻤﻥ ﺼﻔﺭ ﻟﺫﻟﻙ ﻴﻌﺘﺒﺭ ﺍﻟﺤﺭﻑ ﺍﻟﺜﺎﻨﻲ ﻓﻲ ﺍﻟﺴﻠﺴﻠﺔ‬
‫‪ saat‬ﺍﻟﺘﻲ ﺘﺭﺍﻫﺎ ﻜﺒﻴﺭﺓ‪.‬‬
‫‪56‬‬
‫ﺤﺫﻑ ﺤﺭﻭﻑ ﻤﻥ ﺴﻠﺴﻠﺔ‬

‫ﻟﺤﺫﻑ ﺤﺭﻑ ﺃﻭ ﺃﻜﺜﺭ ﻤﻥ ﺍﻟﺴﻠﺴﻠﺔ ﺍﺴﺘﺨﺩﻡ ﺍﻟﺩﺍﻟﺔ ‪ Remove‬ﻭ ﺍﻟﺘﻲ ﺘﻘﻭﻡ ﺒﺤﺫﻑ ﺤﺭﻑ ﺃﻭ ﺃﻜﺜﺭ‬
‫ﺒﺩﺃ ﻤﻥ ﻤﻜﺎﻥ ﻤﺎ ﺘﻘﻭﻡ ﺃﻨﺕ ﺒﺘﺤﺩﻴﺩﻩ‪ .‬ﻜﻤﺎ ﺴﺒﻕ ﻟﻙ ﺃﻥ ﺘﻌﻠﻤﺕ ﻓﺈﻥ ﺍﻟﻌﺩ ﻴﺒﺩﺃ ﻤﻥ ﺍﻟﺼﻔﺭ‪.‬‬
‫ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﻜﻴﻔﻴﺔ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺩﺍﻟﺔ ‪: Remove‬‬

‫"‪Dim s As String = "salamat‬‬
‫)‪Label1.Text = s.Remove(5, 2‬‬
‫ﺍﻟﺸﺭﺡ‬
‫‪ -١‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻷﻭل ﻗﻤﻨﺎ ﺒﺘﻌﺭﻴﻑ ﺴﻠﺴﻠﺔ ‪ s‬ﻭ ﻋﻴﻨﺎ ﻟﻬﺎ ﻗﻴﻤﺔ ﻭﻫﻲ ‪.salamat‬‬
‫‪ -٢‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻨﻲ ﺍﺴﺘﺨﺩﻤﻨﺎ ﺍﻟﺩﺍﻟﺔ ‪ Remove‬ﻟﺤﺫﻑ ﺤﺭﻓﻴﻥ ﻤﻥ ﺍﻟﺴﻠﺴﻠﺔ ﺒﺩﺃ ﻤﻥ ﺍﻟﺤﺭﻑ‬
‫ﺍﻟﺨﺎﻤﺱ‪ .‬ﻟﺫﺍ ﻴﻤﻜﻥ ﺍﻟﻘﻭل ﺒﺄﻥ ﻫﻨﺎﻙ ﻤﻌﺎﻤﻼﻥ ﻟﻠﺩﺍﻟﺔ ‪: Remove‬‬
‫‪ .I‬ﺍﻟﻤﻌﺎﻤل ﺍﻷﻭل ﻟﻠﺩﺍﻟﺔ ‪ Remove‬ﻴﻤﺜل ﻤﻜﺎﻥ ﺒﺩﺃ ﺍﻟﺤﺫﻑ ﻓﻲ ﺍﻟﺴﻠﺴﻠﺔ‪.‬‬
‫‪ .II‬ﻭ ﺍﻟﻤﻌﺎﻤل ﺍﻟﺜﺎﻨﻲ ﻫﻭ ﻋﺩﺩ ﺍﻷﺤﺭﻑ ﺍﻟﺘﻲ ﺘﺭﻴﺩ ﺤﺫﻓﻬﺎ‪.‬‬
‫‪ -٣‬ﺒﻌﺩ ﺘﻨﻔﻴﺫ ﻋﻤﻠﻴﺔ ﺍﻟﺤﺫﻑ ﻗﻤﻨﺎ ﺒﻌﺭﺽ ﺍﻟﻨﺘﻴﺠﺔ ﻋﻠﻰ ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ‪ ،‬ﻨﺘﻴﺠﺔ ﺍﻟﺤﺫﻑ ﻫﻲ ‪.salam‬‬
‫ﻋﻨﺩ ﺤﺫﻑ ﺃﺤﺭﻑ ﻤﻥ ﺴﻠﺴﻠﺔ ﻤﺎ ﺃﻭ ﺇﻀﺎﻓﺔ ﺃﺤﺭﻑ ﻟﻬﺎ ﻓﺈﻥ ﻤﺤﺘﻭﺍﻫﺎ ﻴﺘﻐﻴﺭ ﺤﺴﺏ ﻨﺘﺎﺌﺞ ﺍﻟﺤﺫﻑ‬
‫ﻭﺍﻹﻀﺎﻓﺔ‪.‬‬
‫ﺍﺴﺘﺭﺠﺎﻉ ﺠﺯﺀ ﻤﻥ ﺴﻠﺴﻠﺔ‬

‫ﻓﻲ ﻜﺜﻴﺭ ﻤﻥ ﺍﻷﺤﻴﺎﻥ ﺘﺤﺘﺎﺝ ﺇﻟﻰ ﺍﺴﺘﺭﺠﺎﻉ ﺠﺯﺀ ﻤﻥ ﺴﻠﺴﻠﺔ ﻤﺎ‪ ،‬ﺘﺘﻭﻓﺭ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﺩﺍﻟﺘﻴﻥ‬
‫ﻷﺩﺍﺀ ﻫﺫﻩ ﺍﻟﻌﻤﻠﻴﺔ ‪:‬‬
‫‪-١‬ﺍﻟﺩﺍﻟﺔ ﺍﻷﻭﻟﻰ ﺘﻘﻭﻡ ﺒﺎﺴﺘﺭﺠﺎﻉ ﺠﺯﺀ ﻤﻥ ﺴﻠﺴﻠﺔ ﺒﺩﺃ ﻤﻥ ﻤﻜﺎﻥ ﻤﺎ ﺤﺘﻰ ﻨﻬﺎﻴﺔ ﺍﻟﺴﻠﺴﻠﺔ‪ ،‬ﻓﻲ ﻫﺫﻩ‬
‫ﺍﻟﺤﺎﻟﺔ ﻴﻭﺠﺩ ﻤﻌﺎﻤل ﻭﺍﺤﺩ ﻟﻬﺫﻩ ﺍﻟﺩﺍﻟﺔ ﻭﻫﻭ ﻤﻜﺎﻥ ﺒﺩﺃ ﺍﻻﺴﺘﺭﺠﺎﻉ‪.‬‬
‫ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﻜﻴﻔﻴﺔ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺩﺍﻟﺔ ‪: Substring‬‬

‫)‪Label1.Text = s.Substring(5‬‬
‫‪57‬‬
‫‪ .I‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻷﻭل ﻗﻤﻨﺎ ﺒﺘﻌﺭﻴﻑ ﺴﻠﺴﻠﺔ ﻭ ﻋﻴﻨﺎ ﻟﻬﺎ ﻗﻴﻤﺔ ‪.salamat‬‬
‫‪ .II‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻨﻲ ﻗﻤﻨﺎ ﺒﺎﺴﺘﺭﺠﺎﻉ ﺠﺯﺀ ﻤﻥ ﺍﻟﺴﻠﺴﻠﺔ ‪ s‬ﺒﺩﺃ ﻤﻥ ﺍﻟﺤﺭﻑ ﺍﻟﺨﺎﻤﺱ ﺤﺘﻰ ﻨﻬﺎﻴﺔ‬
‫ﺍﻟﺴﻠﺴﻠﺔ ﺜﻡ ﻋﺭﻀﻨﺎ ﺍﻟﻨﺘﻴﺠﺔ ﻓﻲ ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ ﻭ ﻫﻲ ﺤﺭﻓﻲ ‪.at‬‬
‫‪-٢‬ﺍﻟﺩﺍﻟﺔ ﺍﻟﺜﺎﻨﻴﺔ ﺘﻘﻭﻡ ﺒﺎﺴﺘﺭﺠﺎﻉ ﺠﺯﺀ ﻤﻥ ﺴﻠﺴﻠﺔ ﺒﺩﺃ ﻤﻥ ﻤﻜﺎﻥ ﻤﺎ ﻭ ﺍﻨﺘﻬﺎﺀ ﺒﻤﻜﺎﻥ ﻤﺎ‪ .‬ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ‬
‫ﻴﻭﺠﺩ ﻤﻌﺎﻤﻼﻥ ﻟﻬﺫﻩ ﺍﻟﺩﺍﻟﺔ ﺍﻷﻭل ﻴﻤﺜل ﻤﻜﺎﻥ ﺒﺩﺀ ﺍﻻﺴﺘﺭﺠﺎﻉ ﻭ ﺍﻟﺜﺎﻨﻲ ﻴﻤﺜل ﻋﺩﺩ ﺍﻷﺤﺭﻑ ﺍﻟﺘﻲ ﺘﻭﺩ‬
‫ﺍﺴﺘﺭﺠﺎﻋﻬﺎ‪ .‬ﻟﻨﺄﺨﺫ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻟﻜﻲ ﺘﺘﻀﺢ ﺍﻟﻔﻜﺭﺓ‪.‬‬
‫)‪Label1.Text = s.Substring(3, 2‬‬
‫ﺍﻟﺸﺭﺡ ‪:‬‬
‫‪ -١‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻷﻭل ﻗﻤﻨﺎ ﺒﺘﻌﺭﻴﻑ ﺴﻠﺴﻠﺔ ﻭ ﻋﻴﻨﺎ ﻟﻬﺎ ﻗﻴﻤﺔ ‪.salamat‬‬
‫‪ -٢‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻨﻲ ﻗﻤﻨﺎ ﺒﺘﻨﻔﻴﺫ ﺍﻟﺩﺍﻟﺔ ‪ substring‬ﻟﻜﻲ ﻨﺴﺘﺭﺠﻊ ﺤﺭﻓﻴﻥ ﺒﺩﺃ ﻤﻥ ﺍﻟﺤﺭﻑ ﺍﻟﺜﺎﻟﺙ‬
‫ﻓﻲ ﺍﻟﺴﻠﺴﻠﺔ ‪ s‬ﺜﻡ ﻗﻤﻨﺎ ﺒﻌﺭﺽ ﺍﻟﻨﺘﻴﺠﺔ ﻋﻠﻰ ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ ﻭﻫﻲ ﺤﺭﻓﻲ ‪.am‬‬
‫ﻋﻨﺩ ﺍﺴﺘﺭﺠﺎﻉ ﺠﺯﺀ ﻤﻥ ﺴﻠﺴﻠﺔ ﻤﺎ ﻓﺈﻥ ﺍﻟﻤﺤﺘﻭﻯ ﺍﻷﺼﻠﻲ ﻟﻠﺴﻠﺴﻠﺔ ﻻ ﻴﺘﻐﻴﺭ‪.‬‬
‫ﺒﺤﺙ ﻭ ﺍﺴﺘﺒﺩﺍل ﺠﺯﺀ ﻤﻥ ﺴﻠﺴﻠﺔ‬

‫ﺇﺫﺍ ﺃﺭﺩﺕ ﺃﻥ ﺘﺒﺤﺙ ﻋﻥ ﺤﺭﻑ ﻤﺎ – ﺃﻭ ﺠﺯﺀ ﻤﻥ ﺴﻠﺴﻠﺔ‪ -‬ﺩﺍﺨل ﺴﻠﺴﻠﺔ ﺜﻡ ﺘﺴﺘﺒﺩﻟﻪ ﺒﺤﺭﻑ ﺁﺨﺭ ﻓﺈﻥ‬
‫ﻫﻨﺎﻙ ﺩﺍﻟﺔ ‪ Replace‬ﻭ ﺍﻟﺘﻲ ﺘﻭﻓﺭ ﻟﻙ ﺠﻬﺩﺍ ﻜﺒﻴﺭﺍ‪.‬‬
‫ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﻜﻴﻔﻴﺔ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺩﺍﻟﺔ ‪: Replace‬‬

‫"‪Dim str1 As String = "ppp‬‬
‫)"‪Label1.Text = str1.Replace("p", "k‬‬
‫‪ -١‬ﻋﺭﻓﻨﺎ ﺴﻠﺴﻠﺔ ﺤﺭﻓﻴﺔ ﻭ ﻋﻴﻨﺎ ﻟﻬﺎ ﻗﻴﻤﺔ ‪.ppp‬‬
‫‪ -٢‬ﻗﻤﻨﺎ ﺒﺘﻁﺒﻴﻕ ﺍﻟﺩﺍﻟﺔ ‪ Replace‬ﻋﻠﻰ ﺍﻟﺴﻠﺴﻠﺔ ﻭ ﺍﻟﺘﻲ ﺴﻭﻑ ﺘﻘﻭﻡ ﺒﺎﻟﺒﺤﺙ ﻋﻥ ﻜل ﺤﺭﻑ ‪p‬‬
‫ﺜﻡ ﺘﻘﻭﻡ ﺒﺎﺴﺘﺒﺩﺍﻟﻪ ﺒﺤﺭﻑ ‪ .k‬ﺒﻌﺩ ﺫﻟﻙ ﻗﻤﻨﺎ ﺒﻌﺭﺽ ﺍﻟﻨﺘﻴﺠﺔ ﻋﻠﻰ ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ ﻭ ﺍﻟﺘﻲ ﺴﻭﻑ‬
‫ﺘﻜﻭﻥ ‪.kkk‬‬
‫‪58‬‬
‫ﺘﺤﻭﻴل ﺤﺎﻟﺔ ﺍﻟﺤﺭﻭﻑ ﺇﻟﻰ ﺼﻐﻴﺭﺓ ﻭ ﻜﺒﻴﺭﺓ‬

‫ﻭﻫﻭ ﻤﺎ ﻴﻨﻁﺒﻕ ﻋﻠﻰ ﺤﺭﻭﻑ ﺍﻟﻠﻐﺔ ﺍﻹﻨﺠﻠﻴﺯﻴﺔ‪ .‬ﺘﻭﺠﺩ ﺩﺍﻟﺘﺎﻥ ﻟﺘﺤﻭﻴل ﺍﻟﺤﺭﻭﻑ ﻤﻥ ﺍﻟﺤﺎﻟﺔ ﺍﻟﺼﻐﻴﺭﺓ‬
‫ﺇﻟﻰ ﺍﻟﺤﺎﻟﺔ ﺍﻟﻜﺒﻴﺭﺓ‪ ،‬ﻭ ﺍﻟﻌﻜﺱ ﻭﻫﻤﺎ ‪:‬‬
‫ﺍﻟﺸﺭﺡ‬ ‫ﺍﻟﺩﺍﻟﺔ‬
‫ﺘﻘﻭﻡ ﺒﺘﺤﻭﻴل ﺤﺎﻟﺔ ﺤﺭﻭﻑ ﺴﻠﺴﻠﺔ ﺇﻟﻰ ﺼﻐﻴﺭﺓ‬ ‫)(‪.ToLower‬‬
‫ﺘﻘﻭﻡ ﺒﺘﺤﻭﻴل ﺤﺎﻟﺔ ﺤﺭﻭﻑ ﺴﻠﺴﻠﺔ ﺇﻟﻰ ﻜﺒﻴﺭﺓ‬ ‫)(‪ToUpper‬‬
‫ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﺴﻭﻑ ﻴﺭﺴﺦ ﻤﻔﻬﻭﻡ ﺍﻟﺩﺍﻟﺘﻴﻥ‪.‬‬

‫‪Dim aStr As‬‬ ‫"‪String = "ahmed‬‬
‫‪Dim bStr As‬‬ ‫"‪String = "OMAR‬‬
‫‪Label1.Text‬‬ ‫)(‪= aStr.ToUpper‬‬
‫‪Label2.Text‬‬ ‫)(‪= bStr.ToLower‬‬
‫‪ -١‬ﻗﻤﻨﺎ ﺒﺘﻌﺭﻴﻑ ﺴﻠﺴﻠﺘﻴﻥ ﺍﻷﻭﻟﻰ ﻋﻴﻨﺎ ﻟﻬﺎ ﻗﻴﻤﺔ ‪ ahmed‬ﻭ ﺍﻟﺜﺎﻨﻴﺔ ﻋﻴﻨﺎ ﻟﻬﺎ ﻗﻴﻤﺔ ‪OMAR‬‬
‫‪ -٢‬ﺍﺴﺘﺨﺩﻤﻨﺎ ﺍﻟﺩﺍﻟﺔ ‪ ToUpper‬ﻟﺘﺤﻭﻴل ﺤﺎﻟﺔ ﺤﺭﻭﻑ ﻜﻠﻤﺔ ‪ ahmed‬ﺇﻟﻰ ﺤﺎﻟﺔ ﻜﺒﻴﺭﺓ‬
‫ﺇﻟﻰ ﺤﺎﻟﺔ ﺼﻐﻴﺭﺓ‪.‬‬ ‫‪OMAR‬‬ ‫‪ -٣‬ﺍﺴﺘﺨﺩﻤﻨﺎ ﺍﻟﺩﺍﻟﺔ ‪ ToLower‬ﻟﺘﺤﻭﻴل ﺤﺎﻟﺔ ﺤﺭﻭﻑ ﻜﻠﻤﺔ‬
‫‪ -٤‬ﻗﻤﻨﺎ ﺒﻌﺭﺽ ﺍﻟﻨﺘﺎﺌﺞ ﻋﻠﻰ ﺃﺩﺍﺘﻲ ﻋﻨﻭﺍﻥ ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل)‪(١-٤‬‬
‫ﺸﻜل ‪ : ١ -٤‬ﺘﺤﻭﻴل ﺤﺎﻟﺔ ﺍﻟﺤﺭﻭﻑ ﻤﻥ‬
‫ﺼﻐﻴﺭﺓ ﺇﻟﻰ ﻜﺒﻴﺭﺓ ﻭ ﺍﻟﻌﻜﺱ‬
‫‪59‬‬
‫ﺇﺯﺍﻟﺔ ﺍﻟﻤﺴﺎﻓﺎﺕ ﻭ ﺍﻟﺤﺭﻭﻑ ﻏﻴﺭ ﺍﻟﻤﺭﻏﻭﺏ ﻓﻴﻬﺎ‬

‫ﻓﻲ ﺒﻌﺽ ﺍﻷﺤﻴﺎﻥ ﺘﺭﻴﺩ ﺇﺯﺍﻟﺔ ﺍﻟﻤﺴﺎﻓﺎﺕ ﺍﻟﺘﻲ ﺘﻭﺠﺩ ﻓﻲ ﺒﺩﺍﻴﺔ ﻜل ﺴﻠﺴﻠﺔ ﺃﻭ ﻓﻲ ﻨﻬﺎﻴﺘﻬﺎ ﺃﻭ ﻓﻴﻬﻤﺎ ﻤﻌﺎ‪.‬‬
‫ﻭ ﻟﻨﻀﺭﺏ ﻟﺫﻟﻙ ﻤﺜﺎﻻ ‪ :‬ﺍﻓﺘﺭﺽ ﺃﻥ ﻫﻨﺎﻙ ﻤﺴﺘﻔﻴﺩﺍ ﻴﺩﺨل ﺃﺴﻤﺎﺀ ﺃﺸﺨﺎﺹ ﻓﻲ ﻤﺭﺒﻊ ﻨﺹ ﻭ ﺘﺭﻴﺩ ﺃﻥ‬
‫ﺘﺘﺄﻜﺩ ﻤﻥ ﺃﻨﻪ ﺃﺩﺨل ﺸﻴﺌﺎ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ‪ ،‬ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﻟﻭ ﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﻤﺴﺎﻓﺔ ﻓﺈﻨﻙ ﻟﻥ ﺘﺩﺭﻱ‬
‫ﻫل ﺍﻟﺫﻱ ﺃﺩﺨﻠﻪ ﺍﺴﻡ ﺃﻡ ﻤﺴﺎﻓﺔ ﻤﺎ ﻟﻡ ﺘﻘﻡ ﺒﺈﺯﺍﻟﺔ ﺍﻟﻤﺴﺎﻓﺎﺕ ﺍﻟﻘﺒﻠﻴﺔ ﻭ ﺍﻟﺒﻌﺩﻴﺔ ﻟﻜل ﺴﻠﺴﻠﺔ‪.‬‬
‫ﻟﻨﺄﺨﺫ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ‪:‬‬

‫" ‪Dim str As String = " ahmed‬‬
‫)(‪Label1.Text = str.Trim‬‬
‫ﻟﻜﻥ ﻻﺤﻅ ﺃﻥ ﺍﻟﻘﻴﻤﺔ‬ ‫‪ahmed‬‬ ‫‪ -١‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻷﻭل ﻗﻤﻨﺎ ﺒﺘﻌﺭﻴﻑ ﺴﻠﺴﻠﺔ ‪ str‬ﻭ ﻋﻴﻨﺎ ﻟﻬﺎ ﺍﻟﻘﻴﻤﺔ‬
‫ﺃﺤﻤﺩ ﺘﺒﺩﺃ ﺒﻤﺴﺎﻓﺔ ﻭ ﺘﻨﺘﻬﻲ ﺒﻤﺴﺎﻓﺔ‪.‬‬
‫‪ -٢‬ﻹﺯﺍﻟﺔ ﺍﻟﻤﺴﺎﻓﺔ ﺍﻟﻘﺒﻠﻴﺔ ﻭ ﺍﻟﺒﻌﺩﻴﺔ ﻗﻤﻨﺎ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﺩﺍﻟﺔ ‪ Trim‬ﻭ ﻤﻥ ﺜﻡ ﻋﺭﻀﻨﺎ ﺍﻟﻨﺘﻴﺠﺔ ﻋﻠﻰ‬
‫ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ ﻭ ﺍﻟﻨﺘﻴﺠﺔ ﻫﻲ ﻜﻠﻤﺔ ﺃﺤﻤﺩ ﺒﺩﻭﻥ ﻤﺴﺎﻓﺎﺕ ﻗﺒﻠﻴﺔ ﺃﻭ ﺒﻌﺩﻴﺔ‪.‬‬
‫ﺘﺒﻁﻴﻥ ﺴﻠﺴﻠﺔ ﺒﻤﺴﺎﻓﺔ ﺒﺭﻤﺯ ﻤﻥ ﺍﻟﻴﻤﻴﻥ ﺃﻭ ﺍﻟﺸﻤﺎل‬

‫ﻨﻘﺼﺩ ﺒﺘﺒﻁﻴﻥ ﺴﻠﺴﻠﺔ ﺒﻤﺴﺎﻓﺔ ﻤﻥ ﺍﻟﻴﻤﻴﻥ ﺃﻭ ﺍﻟﺸﻤﺎل ﺃﻥ ﺘﻀﺎﻑ ﺇﻟﻴﻬﺎ ﻤﺴﺎﻓﺎﺕ ﻤﻥ ﺠﻬﺘﻴﻥ ﻫﻤﺎ ‪:‬‬
‫‪ -١‬ﺘﺒﻁﻴﻥ ﻤﻥ ﺍﻟﺠﻬﺔ ﺍﻟﻴﻤﻨﻰ ‪ :‬ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﻨﺴﺘﺨﺩﻡ ﺍﻟﺩﺍﻟﺔ ‪ PadLeft‬ﻭ ﺍﻟﺘﻲ ﺘﻘﻭﻡ ﺒﺘﺒﻁﻴﻥ‬
‫ﺴﻠﺴﻠﺔ ﻤﺎ ﺒﻤﺴﺎﻓﺔ ﺃﻭ ﺒﺭﻤﺯ ﺁﺨﺭ‪.‬‬
‫ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﻜﻴﻔﻴﺔ ﺘﺒﻁﻴﻥ ﺴﻠﺴﻠﺔ ‪:‬‬
‫"‪Dim str1 As String = "MyString‬‬

‫)‪Label1.Text = str1.PadLeft(10‬‬
‫‪ -١‬ﻋﺭﻓﻨﺎ ﺴﻠﺴﻠﺔ ﻭ ﻋﻴﻨﺎ ﻟﻬﺎ ﺍﻟﻘﻴﻤﺔ ‪. MyString‬‬
‫‪ -٢‬ﻗﻤﻨﺎ ﺒﺎﺴﺘﺩﻋﺎﺀ ﺍﻟﺩﺍﻟﺔ ‪ PadLeft‬ﻭ ﺍﻋﻁﺎﺌﻬﺎ ﻤﻌﺎﻤل ‪ ١٠‬ﻴﻤﺜل ﻫﺫﺍ ﺍﻟﻤﻌﺎﻤل ﺍﻟﻁﻭل ﺍﻟﻜﻠﻲ‬
‫ﻟﻠﺴﻠﺴﻠﺔ ﺍﻟﻨﺎﺘﺠﺔ‪ .‬ﻓﺈﺫﺍ ﻜﺎﻨﺕ ﺍﻟﺴﻠﺴﻠﺔ ﺍﻷﺼﻠﻴﺔ ‪ MyString‬ﻟﻬﺎ ﻁﻭل ‪ ٨‬ﻓﺈﻥ ﺍﻟﻁﻭل ﻟﻠﺴﻠﺴﻠﺔ‬
‫‪60‬‬
‫ﺴﻴﻜﻭﻥ ‪ ١٠‬ﻭ ﺴﺘﻜﻭﻥ ﺍﻟﻨﺘﻴﺠﺔ ﻜﺎﻟﺘﺎﻟﻲ " ‪ "MyString‬ﻻ ﺤﻅ ﺃﻨﻪ ﺘﻡ ﺍﻀﺎﻓﺔ ﻤﺴﺎﻓﺘﻴﻥ ﺇﻟﻰ‬
‫ﺍﻟﺠﻬﺔ ﺍﻟﻴﻤﻨﻰ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻟﻤﺎﺫﺍ ﻤﺴﺎﻓﺘﻴﻥ ؟ ﻻﺤﻅ ﺃﻥ ﺍﻟﻤﻌﺎﻤل=‪ ١٠‬ﻭ ﺃﻥ ﻁﻭل ﺍﻟﺴﻠﺴﻠﺔ=‪٨‬‬

‫‪ ٢=٨-١٠‬ﻓﻜﺄﻨﻨﺎ ﻨﻘﻭل ﺃﻀﻑ ﻤﺴﺎﻓﺘﻴﻥ ﻟﻠﺴﻠﺴﻠﺔ ﻤﻥ ﺠﻬﺔ ﺍﻟﻴﻤﻴﻥ‪.‬‬
‫ﺇﺫﺍ ﻜﺎﻥ ﺍﻟﻤﻌﺎﻤل ﺃﻗل ﻤﻥ ﻁﻭل ﺍﻟﺴﻠﺴﻠﺔ ﻓﻠﻥ ﻴﺘﻡ ﺇﻀﺎﻓﺔ ﺃﻱ ﺸﻲﺀ ‪.‬‬
‫‪ -٢‬ﺘﺒﻁﻴﻥ ﻤﻥ ﺍﻟﺠﻬﺔ ﺍﻟﻴﺴﺭﻯ ‪ :‬ﻤﺎ ﻗﻴل ﻓﻲ ﺍﻟﺘﺒﻁﻴﻥ ﻤﻥ ﺍﻟﺠﻬﺔ ﺍﻟﻴﻤﻨﻰ ﻴﻘﺎل ﻫﻨﺎ ﺇﻻ ﺃﻨﻨﺎ ﻨﺴﺘﺨﺩﻡ‬
‫‪.PadRight‬‬ ‫ﺩﺍﻟﺔ ﺃﺨﺭﻯ ﻫﻲ‬
‫ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﻜﻴﻔﻴﺔ ﺘﺒﻁﻴﻥ ﺴﻠﺴﻠﺔ ﻤﻥ ﺍﻟﺠﻬﺔ ﺍﻟﻴﻤﻨﻰ ‪: :‬‬

‫"‪Dim str1 As String = "MyString‬‬
‫)‪Label1.Text = str1.PadRight(10‬‬
‫‪ -١‬ﻋﺭﻓﻨﺎ ﺴﻠﺴﻠﺔ ﻭ ﻋﻴﻨﺎ ﻟﻬﺎ ﺍﻟﻘﻴﻤﺔ ‪. MyString‬‬
‫‪-٢‬ﻗﻤﻨﺎ ﺒﺎﺴﺘﺩﻋﺎﺀ ﺍﻟﺩﺍﻟﺔ ‪ PadRight‬ﻭ ﺍﻋﻁﺎﺌﻬﺎ ﻤﻌﺎﻤل ‪ ١٠‬ﻴﻤﺜل ﻫﺫﺍ ﺍﻟﻤﻌﺎﻤل ﺍﻟﻁﻭل ﺍﻟﻜﻠﻲ‬
‫ﻟﻠﺴﻠﺴﻠﺔ ﺍﻟﻨﺎﺘﺠﺔ‪ .‬ﻓﺈﺫﺍ ﻜﺎﻨﺕ ﺍﻟﺴﻠﺴﻠﺔ ﺍﻷﺼﻠﻴﺔ ‪ MyString‬ﻟﻬﺎ ﻁﻭل ‪ ٨‬ﻓﺈﻥ ﺍﻟﻁﻭل ﻟﻠﺴﻠﺴﻠﺔ‬
‫ﺴﻴﻜﻭﻥ ‪ ١٠‬ﻭ ﺴﺘﻜﻭﻥ ﺍﻟﻨﺘﻴﺠﺔ ﻜﺎﻟﺘﺎﻟﻲ "‪ " MyString‬ﻻ ﺤﻅ ﺃﻨﻪ ﺘﻡ ﺇﻀﺎﻓﺔ ﻤﺴﺎﻓﺘﻴﻥ ﺇﻟﻰ ﺍﻟﺠﻬﺔ‬
‫ﺍﻟﻴﺴﺭﻯ‪.‬‬
‫‪61‬‬
‫ﺍﻟﺒﺤﺙ ﻓﻲ ﺍﻟﺴﻼﺴل‬
‫ﺇﻥ ﻤﻥ ﺍﻟﻌﻤﻠﻴﺎﺕ ﺍﻷﺴﺎﺴﻴﺔ ﻭ ﺍﻟﻤﺘﻜﺭﺭﺓ ﺩﺍﺌﻤﺎ ﻫﻲ ﺍﻟﺒﺤﺙ ﻓﻲ ﺴﻠﺴﻠﺔ ﻤﺎ‪ .‬ﺘﺴﺘﻁﻴﻊ ﺍﻟﺒﺤﺙ ﺩﺍﺨل‬
‫ﺴﻠﺴﻠﺔ ﻤﻥ ﺨﻼل ﺍﻟﺩﺍﻟﺔ ‪ indexOf‬ﻭ ﺍﻟﺘﻲ ﺴﻭﻑ ﺘﻘﻭﻡ ﺒﺈﺭﺠﺎﻉ ﻤﻭﻗﻊ ﺃﻭل ﻨﺘﻴﺠﺔ ﺒﺤﺙ ﺇﻴﺠﺎﺒﻴﺔ‪.‬‬
‫ﻴﻭﺠﺩ ﺴﺘﺔ ﻁﺭﻕ ﻟﻠﺒﺤﺙ ﺩﺍﺨل ﺴﻠﺴﻠﺔ ﻜﻠﻬﺎ ﻤﺘﻭﻓﺭﺓ ﻤﻥ ﺨﻼل ﻫﺫﻩ ﺍﻟﺩﺍﻟﺔ ﻭﻫﻲ‪:‬‬
‫ﺍﻟﺸﺭﺡ‬ ‫ﺍﻟﺩﺍﻟﺔ‬
‫ﻟﺩﻴﻨﺎ ﻤﻌﺎﻤل ﻭﺍﺤﺩ ﻭﻫﻭ ﺍﻟﺤﺭﻑ ﺍﻟﺫﻱ ﺘﺭﻴﺩ‬
‫_ (‪IndexOf‬‬
‫_ ‪ByVal value As Char‬‬
‫‪ ) As Integer‬ﺍﻟﺒﺤﺙ ﻋﻨﻪ ﻭﻟﺩﻴﻨﺎ ﻗﻴﻤﺔ ﻤﺭﺠﻌﺔ ﻫﻲ ﻨﺘﻴﺠﺔ‬

‫ﺍﻟﺒﺤﺙ‪.‬‬
‫ﻟﺩﻴﻨﺎ ﻤﻌﺎﻤل ﻭﺍﺤﺩ ﻫﻭ ﺍﻟﺴﻠﺴﻠﺔ ﺍﻟﺘﻲ ﻨﺭﻴﺩ ﺍﻟﺒﺤﺙ‬
‫_ ‪ByVal value As String‬‬
‫‪ ) As Integer‬ﻋﻨﻬﺎ ﺩﺍﺨل ﺍﻟﺴﻠﺴﻠﺔ ﺍﻟﺤﺎﻟﻴﺔ‪ .‬ﻭﻟﺩﻴﻨﺎ ﻗﻴﻤﺔ ﻤﺭﺠﻌﺔ‬

‫ﻫﻲ ﻨﺘﻴﺠﺔ ﺍﻟﺒﺤﺙ‪.‬‬
‫ﻟﺩﻴﻨﺎ ﻤﻌﺎﻤﻼﻥ ﻫﻤﺎ ﺍﻟﺤﺭﻑ ﺍﻟﺫﻱ ﻨﺭﻴﺩ ﺍﻟﺒﺤﺙ‬
‫_ ‪ByVal value As Char,‬‬
‫_ ‪ByVal startIndex As Integer‬‬
‫‪ ) As Integer‬ﻋﻨﻪ ﻭ ﻤﻜﺎﻥ ﺒﺩﺀ ﺍﻟﺒﺤﺙ‪ .‬ﻭﻟﺩﻴﻨﺎ ﻗﻴﻤﺔ ﻤﺭﺠﻌﺔ‬
‫ﻟﺩﻴﻨﺎ ﻤﻌﺎﻤﻼﻥ ﻫﻤﺎ ﺍﻟﺴﻠﺴﻠﺔ ﺍﻟﺘﻲ ﻨﺭﻴﺩ ﺍﻟﺒﺤﺙ‬
‫_ ‪ByVal value As String,‬‬
‫_ ‪ByVal startIndex As Integer‬‬
‫‪ ) As Integer‬ﻋﻨﻬﺎ ﻭ ﻤﻜﺎﻥ ﺒﺩﺀ ﺍﻟﺒﺤﺙ‪ .‬ﻭﻟﺩﻴﻨﺎ ﻗﻴﻤﺔ ﻤﺭﺠﻌﺔ‬
‫ﻟﺩﻴﻨﺎ ﺜﻼﺜﺔ ﻤﻌﺎﻤﻼﺕ ﻫﻲ ﺍﻟﺤﺭﻑ ﺍﻟﺫﻱ ﻨﺭﻴﺩ‬
‫_ ‪ByVal value As Char,‬‬
‫_ ‪ByVal startIndex As Integer,‬‬
‫ﺍﻟﺒﺤﺙ ﻋﻨﻪ ﻭ ﻤﻜﺎﻥ ﺒﺩﺀ ﺍﻟﺒﺤﺙ ﻭ ﻋﺩﺩ ﺍﻟﺤﺭﻭﻑ‬ ‫_ ‪ByVal count As Integer‬‬
‫‪) As Integer‬‬
‫ﺍﻟﺘﻲ ﻨﺭﻴﺩ ﺃﻥ ﺘﺘﻡ ﻋﻠﻴﻬﺎ ﻋﻤﻠﻴﺔ ﺍﻟﺒﺤﺙ‪ .‬ﻭﻟﺩﻴﻨﺎ‬
‫ﻗﻴﻤﺔ ﻤﺭﺠﻌﺔ ﻫﻲ ﻨﺘﻴﺠﺔ ﺍﻟﺒﺤﺙ‪.‬‬
‫ﻟﺩﻴﻨﺎ ﺜﻼﺜﺔ ﻤﻌﺎﻤﻼﺕ ﻫﻲ ﺍﻟﺴﻠﺴﻠﺔ ﺍﻟﺘﻲ ﻨﺭﻴﺩ‬
‫_ ‪ByVal value As String,‬‬
‫_ ‪ByVal startIndex As Integer,‬‬
‫ﺍﻟﺒﺤﺙ ﻋﻨﻬﺎ ﻭ ﻤﻜﺎﻥ ﺒﺩﺀ ﺍﻟﺒﺤﺙ ﻭ ﻋﺩﺩ ﺍﻟﺤﺭﻭﻑ‬ ‫_ ‪ByVal count As Integer‬‬
‫‪) As Integer‬‬
‫ﺍﻟﺘﻲ ﻨﺭﻴﺩ ﺃﻥ ﺘﺘﻡ ﻋﻠﻴﻬﺎ ﻋﻤﻠﻴﺔ ﺍﻟﺒﺤﺙ‪ .‬ﻭﻟﺩﻴﻨﺎ‬
‫ﻗﻴﻤﺔ ﻤﺭﺠﻌﺔ ﻫﻲ ﻨﺘﻴﺠﺔ ﺍﻟﺒﺤﺙ‪.‬‬
‫‪62‬‬
‫ﻟﻨﺄﺨﺫ ﺍﻷﻤﺜﻠﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻭ ﺍﻟﺘﻲ ﻤﻥ ﺨﻼﻟﻬﺎ ﺘﺘﻀﺢ ﺍﻟﻔﻜﺭﺓ‪.‬‬

‫‪ -١‬ﺍﻟﺒﺤﺙ ﻋﻥ ﺤﺭﻑ‬
‫"‪Dim str As String = "salamat‬‬
‫)”‪Label1.Text = str.IndexOf("a‬‬
‫ﺍﻟﻁﺭﻴﻘﺔ‬
‫‪ -I‬ﻋﺭﻓﻨﺎ ﺴﻠﺴﻠﺔ ﻭ ﻋﻴﻨﺎ ﻟﻬﺎ ﻗﻴﻤﺔ ‪salamat‬‬
‫‪ -II‬ﺒﺤﺜﻨﺎ ﻋﻥ ﺤﺭﻑ ‪ a‬ﺩﺍﺨل ﺍﻟﺴﻠﺴﻠﺔ ﺜﻡ ﺃﺭﺠﻌﻨﺎ ﺍﻟﻨﺘﻴﺠﺔ ﺇﻟﻰ ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ‪ ،‬ﻭ ﺍﻟﻨﺘﻴﺠﺔ‬
‫ﻫﻲ ‪ ١‬ﻭ ﺍﻟﺫﻱ ﻴﻤﺜل ﺭﻗﻡ ﻤﻭﻗﻊ ﺤﺭﻑ ‪ a‬ﺩﺍﺨل ﺍﻟﺴﻠﺴﻠﺔ‪.‬‬
‫‪-٢‬ﺍﻟﺒﺤﺙ ﻋﻥ ﺤﺭﻑ ﺒﺩﺃ ﻤﻥ ﻤﻜﺎﻥ ﻤﺎ‪.‬‬

‫)‪Label1.Text = str.IndexOf("a”,4‬‬
‫ﺍﻟﻁﺭﻴﻘﺔ ‪:‬‬
‫‪-I‬ﻋﺭﻓﻨﺎ ﺴﻠﺴﻠﺔ ﻭ ﻋﻴﻨﺎ ﻟﻬﺎ ﻗﻴﻤﺔ ‪.salamat‬‬
‫‪-II‬ﺒﺤﺜﻨﺎ ﻋﻥ ﺤﺭﻑ ‪ a‬ﺩﺍﺨل ﺍﻟﺴﻠﺴﻠﺔ ﺒﺩﺃ ﻤﻥ ﺍﻟﻤﻭﻗﻊ ﺍﻟﺭﺍﺒﻊ ﺜﻡ ﺃﺭﺠﻌﻨﺎ‬
‫ﺍﻟﻨﺘﻴﺠﺔ ﺇﻟﻰ ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ‪ ،‬ﻭ ﺍﻟﻨﺘﻴﺠﺔ ﻫﻲ ‪ ٥‬ﻭ ﺍﻟﺫﻱ ﻴﻤﺜل ﺭﻗﻡ ﻤﻭﻗﻊ ﺤﺭﻑ ‪ a‬ﺩﺍﺨل ﺍﻟﺴﻠﺴﻠﺔ ﺒﺩﺃ‬
‫ﻤﻥ ﺍﻟﻤﻭﻗﻊ ﺍﻟﺭﺍﺒﻊ‪.‬‬
‫‪-٣‬ﺍﻟﺒﺤﺙ ﻋﻥ ﺤﺭﻑ ﻤﻊ ﺘﺤﺩﻴﺩ ﻤﻜﺎﻥ ﺒﺩﺃ ﺍﻟﺒﺤﺙ ﻭ ﻤﻜﺎﻥ ﺍﻨﺘﻬﺎﺌﻪ‬

‫)‪Label1.Text = str.IndexOf("m”,3,2‬‬
‫ﺍﻟﻁﺭﻴﻘﺔ ‪:‬‬
‫‪-I‬ﻋﺭﻓﻨﺎ ﺴﻠﺴﻠﺔ ﻭ ﻋﻴﻨﺎ ﻟﻬﺎ ﻗﻴﻤﺔ ‪.salamat‬‬
‫‪-II‬ﺒﺤﺜﻨﺎ ﻋﻥ ﺤﺭﻑ ‪ m‬ﺩﺍﺨل ﺍﻟﺴﻠﺴﻠﺔ ﺒﺩﺃ ﻤﻥ ﺍﻟﻤﻭﻗﻊ ﺍﻟﺜﺎﻟﺙ ﺒﻁﻭل ‪ ٢‬ﻤﻤﺎ‬
‫ﻴﻌﻨﻲ ﺃﻥ ﺍﻟﺒﺤﺙ ﺴﻭﻑ ﻴﺘﻭﻗﻑ ﻓﻲ ﺍﻟﻤﻭﻗﻊ ﺍﻟﺨﺎﻤﺱ‪ ،‬ﺜﻡ ﺃﺭﺠﻌﻨﺎ ﺍﻟﻨﺘﻴﺠﺔ ﺇﻟﻰ ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ‪ ،‬ﻭ‬
‫ﺍﻟﻨﺘﻴﺠﺔ ﻫﻲ ‪ ٤‬ﻭ ﺍﻟﺫﻱ ﻴﻤﺜل ﺭﻗﻡ ﻤﻭﻗﻊ ﺤﺭﻑ ‪ m‬ﺩﺍﺨل ﺍﻟﺴﻠﺴﻠﺔ ﺒﺩﺃ ﻤﻥ ﺍﻟﻤﻭﻗﻊ ﺍﻟﺜﺎﻟﺙ‪.‬‬
‫‪63‬‬
‫ﺍﻟﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﻤﻌﻨﻰ ﻨﺘﺎﺌﺞ ﺍﻟﺒﺤﺙ‬

‫ﺍﻟﺸﺭﺡ‬ ‫ﺍﻟﻘﻴﻤﺔ‬
‫ﻨﺘﻴﺠﺔ ﺍﻟﺒﺤﺙ ﺴﻠﺒﻴﺔ‬ ‫‪١-‬‬
‫ﻤﻭﻗﻊ ﺃﻭل ﻨﺘﻴﺠﺔ ﺇﻴﺠﺎﺒﻴﺔ‬ ‫ﺃﻱ ﻋﺩﺩ ﺼﺤﻴﺢ ﻤﻥ ﺼﻔﺭ ﺃﻭ ﺃﻜﺒﺭ‬
‫ﺍﻟﺒﺤﺙ ﻴﻌﺘﻤﺩ ﻋﻠﻰ ﺤﺎﻟﺔ ﺍﻷﺤﺭﻑ‪ .‬ﻓﻠﻭ ﺃﺩﺨﻠﺕ ﺤﺭﻑ ‪ n‬ﻟﻠﺒﺤﺙ ﻋﻨﻪ ﺩﺍﺨل ﺴﻠﺴﻠﺔ ﻭ ﻜﺎﻥ‬
‫ﺍﻟﻤﻭﺠﻭﺩ ‪ N‬ﻓﺈﻥ ﺍﻟﻨﺘﻴﺠﺔ ﺴﻠﺒﻴﺔ‪.‬‬
‫‪64‬‬
‫ﻤﺜﺎل ﺘﺩﺭﻴﺒﻲ ﺸﺎﻤل ﻟﻜل ﺃﻨﻭﺍﻉ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺴﻼﺴل‬
‫ﺍﳍﺪﻑ ‪ :‬ﻳﻬﺪﻑ ﻫﺬﺍ ﺍﻟﺘﺪﺭﻳﺐ ﺇﱃ ﺗﻌﻠﻴﻤﻚ ﲨﻴﻊ ﺃﻧﻮﺍﻉ ﺍﻟﺘﻌﺎﻣﻞ ﺍﻟﺴﺎﺑﻘﺔ ﻣﻊ ﺍﻟﺴﻼﺳﻞ ﳑﺎ ﻳﻜﻮﻥ ﻟﻪ ﺍﻷﺛﺮ ﺍﻹﳚﺎﰊ ﰲ‬
‫ﺗﺴﻬﻴﻞ ﺍﻟﱪﳎﺔ ﰲ ﺑﻴﺌﺔ ﺍﻟﺪﻭﺕ ﻧﺖ‪.‬‬
‫ﺍﻷﺩﻭﺍﺕ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ‪ :‬ﻤﺭﺒﻊ ﻤﺠﻤﻭﻋﺎﺕ‪ ،‬ﺴﺘﺔ ﺃﺯﺭﺍﺭ ﺍﺨﺘﻴﺎﺭ‪ ،‬ﻤﺭﺒﻊ ﻨﺹ ﻭﺍﺤﺩ‪ ،‬ﺨﻤﺴﺔ ﺃﺩﺍﻭﺍﺕ‬
‫ﻋﻨﻭﺍﻥ‪ ،‬ﺯﺭ ﺃﻤﺭ ﺍﻨﻅﺭ ﺸﻜل )‪(٢-٤‬‬
‫ﻨﻅﺭﺓ ﻋﻠﻰ ﺘﺼﻤﻴﻡ ﺍﻟﻨﻤﻭﺫﺝ‬

‫ﺸﻜل ‪ : ٢ -٤‬ﺘﺼﻤﻴﻡ ﺍﻟﻨﻤﻭﺫﺝ‬
‫ﻤﺎﺫﺍ ﺴﻴﺤﺩﺙ‪ :‬ﺴﻭﻑ ﻴﻜﻭﻥ ﻟﺩﻴﻨﺎ ﺴﺘﺔ ﺃﺯﺭﺍﺭ ﺃﻤﺭ ﻜل ﻤﻨﻬﺎ ﻴﻤﺜل ﻨﻭﻉ ﻤﻥ ﺃﻨﻭﺍﻉ ﺍﻟﻌﻤﻠﻴﺎﺕ ﻋﻠﻰ‬
‫ﺍﻟﺴﻼﺴل ﻜﻤﺎ ﺴﻴﻜﻭﻥ ﻟﺩﻴﻨﺎ ﺯﺭ ﺃﻤﺭ ﻴﻨﻔﺫ ﺍﻟﻌﻤﻠﻴﺔ ﺒﻨﺎﺀ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ ﺍﻟﺫﻱ ﺘﻡ ﺍﺨﺘﻴﺎﺭﻩ‪ .‬ﻜﻤﺎ ﺘﻼﺤﻅ‬
‫ﻤﻥ ﺘﺼﻤﻴﻡ ﺍﻟﻨﻤﻭﺫﺝ ﻴﻭﺠﺩ ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ ﻤﻜﺘﻭﺏ ﻋﻠﻴﻬﺎ ‪ ، salamat‬ﻫﺫﻩ ﺍﻷﺩﺍﺓ ﺴﺘﻜﻭﻥ ﻤﺤﻭﺭ‬
‫ﺍﻟﻌﻤﻠﻴﺎﺕ‪ ،‬ﻜﻤﺎ ﺴﻴﻜﻭﻥ ﻫﻨﺎﻙ ﻤﺭﺒﻊ ﻨﺹ ﺘﺩﺨل ﻓﻴﻪ ﺍﻟﻘﻴﻤﺔ ﺒﻨﺎﺀ ﻋﻠﻰ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﻤﺨﺘﺎﺭﺓ ﺜﻡ ﺴﺘﻅﻬﺭ‬
‫ﺍﻟﻨﺘﻴﺠﺔ ﻓﻲ ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ‪ .‬ﻟﻨﺄﺨﺫ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻋﻠﻰ ﺇﺤﺩﻯ ﺍﻟﻌﻤﻠﻴﺎﺕ ‪:‬‬
‫‪ -١‬ﺍﺨﺘﺭ ﻨﻭﻉ ﺍﻟﻌﻤﻠﻴﺔ ﻤﻘﺎﺭﻨﺔ ﺴﻠﺴﻠﺘﻴﻥ ﻤﻥ ﺃﺯﺭﺍﺭ ﺍﻻﺨﺘﻴﺎﺭ‪.‬‬
‫‪ -٢‬ﻗﻡ ﺒﺈﺩﺨﺎل ﺍﻟﺴﻠﺴﻠﺔ ﺍﻟﺘﻲ ﺘﺭﻴﺩ ﺃﻥ ﺘﻘﺎﺭﻨﻬﺎ ﺒﺎﻟﺴﻠﺴﻠﺔ ﺍﻟﻤﻜﺘﻭﺒﺔ ﻋﻠﻰ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ‪.salamat‬‬
‫‪ -٣‬ﺍﻀﻐﻁ ﺯﺭ ﺍﻷﻤﺭ ﻟﺘﻅﻬﺭ ﻟﻙ ﺍﻟﻨﺘﻴﺠﺔ ﻋﻠﻰ ﺃﺩﺍﺓ ﺍﻟﻌﻨﻭﺍﻥ ﺍﻟﺘﻲ ﻜﺘﺏ ﺒﺠﺎﻨﺒﻬﺎ ﻨﺘﻴﺠﺔ ﺍﻟﻌﻤﻠﻴﺔ‪.‬‬
‫‪65‬‬
kal_judaia@hotmail.com ‫ﺧﺎﻟﺪ اﻟﺠﺪﻳﻊ‬
‫ﺍﻟﺨﻁﻭﺍﺕ‬
‫ ﻗﻡ ﺒﺈﻨﺸﺎﺀ ﻨﻤﻭﺫﺝ ﺜﻡ ﻀﻊ ﻓﻴﻪ ﺍﻷﺩﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻤﻊ ﻀﺒﻁ ﺨﺼﺎﺌﺹ ﺍﻷﺩﻭﺍﺕ ﻜﻤﺎ ﻫﻭ ﻭﺍﺭﺩ‬-١
: ‫ﻓﻲ ﺍﻟﺠﺩﻭل‬
‫اﻟﻘﻴﻤﺔ‬ ‫اﻟﺨﺎﺻﻴﺔ‬ ‫اﺳﻢ اﻷداة‬
WorkWithString Name Form
‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﺔ‬ Text
True RightToLeft
Simplified Arabic Font
rdoAdd Name RadioButton
‫إﺿﺎﻓﺔ إﻟﻰ ﺳﻠﺴﻠﺔ‬ Text
rdoSub Name RadioButton
‫اﺳﺘﺮﺟﺎع ﺣﺮوف ﻣﻦ ﺳﻠﺴﻠﺔ‬ Text
rdoCon Name RadioButton
‫دﻣﺞ ﺳﻠﺴﻠﺘﻴﻦ‬ Text
rdoComp Name RadioButton
‫ﻣﻘﺎرﻧﺔ ﺳﻠﺴﻠﺘﻴﻦ‬ Text
rdoSmall Name RadioButton
‫ﺗﺤﻮﻳﻞ ﺣﺎﻟﺔ اﻟﺤﺮوف إﻟﻰ ﺻﻐﻴﺮة‬ Text
rdoCap Name RadioButton
‫ﺗﺤﻮﻳﻞ ﺣﺎﻟﺔ اﻟﺤﺮوف إﻟﻰ آﺒﻴﺮة‬ Text
rdoSearch Name RadioButton
‫اﻟﺒﺤﺚ ﻓﻲ ﺳﻠﺴﻠﺔ‬ Text
rdoRemove Name RadioButton
‫ﺣﺬف ﻣﻦ ﺳﻠﺴﻠﺔ‬ Text
Button1 Name Button
‫ﺗﻨﻔﻴﺬ اﻟﻌﻤﻠﻴﺔ‬ Text
Label2 Name Label
‫اﺟﺮاء اﻟﻌﻤﻠﻴﺎت ﻋﻠﻰ اﻟﺴﻠﺴﻠﺔ‬ Text
lblSal Name Label
salamat Text
Label3 Name Label
‫اﻟﻤﺪﺧﻞ‬ Text
txtInput Name TextBox
Text
Label5 Name Label
‫ﻧﺘﻴﺠﺔ اﻟﻌﻤﻠﻴﺔ‬ Text
lblRes Name Label
Label4 Text
66
‫ ﻗﻡ ﺒﺘﺼﻤﻴﻡ ﺍﻟﻨﻤﻭﺫﺝ ﻜﻤﺎ ﻫﻭ ﻤﻭﻀﺢ ﻓﻲ ﺍﻟﺨﺼﺎﺌﺹ ﻭ ﺸﻜل ﺍﻟﺘﺼﻤﻴﻡ ﺍﻟﺴﺎﺒﻕ‬-٢

‫ ﺍﻨﻘﺭ ﻤﺯﺩﻭﺠﺎ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ ﻟﺘﻨﺘﻘل ﺇﻟﻰ ﺤﺩﺙ ﺍﻟﻨﻘﺭ ﺍﻟﺨﺎﺹ ﺒﺯﺭ ﺍﻷﻤﺭ ﻭ ﺍﻜﺘﺏ ﺍﻟﻜﻭﺩ‬-٣
: ‫ﺍﻟﺘﺎﻟﻲ‬
‫ﺘﺴﺘﻁﻴﻊ ﻨﺴﺦ ﻫﺫﺍ ﺍﻟﺘﺩﺭﻴﺏ ﻤﻥ ﺍﻟﻘﺭﺹ ﺍﻟﻤﺭﻓﻕ ﻤﻊ ﺍﻟﻜﺘﺎﺏ‬
If rdoAdd.Checked Then
If txtInput.Text.Trim <> "" Then
lblRes.Text = lblSal.Text().Insert(2, txtInput.Text)
End If
End If
If rdoSub.Checked Then
If txtInput.Text.Trim <> "" And IsNumeric(txtInput.Text) Then
lblRes.Text = lblSal.Text.Substring(txtInput.Text)
End If
End If
If rdoCon.Checked Then
lblRes.Text = String.Concat(lblSal.Text, txtInput.Text)
End If
End If
If rdoComp.Checked Then
lblRes.Text = String.Compare(lblSal.Text, txtInput.Text)
End If
End If
If rdoSmall.Checked Then
lblRes.Text = txtInput.Text.ToLower
End If
End If
If rdoCap.Checked Then
lblRes.Text = txtInput.Text.ToUpper
End If
End If
If rdoSearch.Checked Then
lblRes.Text = lblSal.Text.IndexOf(txtInput.Text)
End If
End If
If rdoRemove.Checked Then
If txtInput.Text.Trim <> "" And IsNumeric(txtInput.Text) Then
lblRes.Text = lblSal.Text.Remove(txtInput.Text, 1)
End If
End If
67
‫ﺘﻌﻠﻴﻤﺎﺕ‬
‫‪ -١‬ﺒﻨﺎﺀ ﻋﻠﻰ ﺯﺭ ﺍﻻﺨﺘﻴﺎﺭ ﺍﻟﺫﻱ ﺘﻡ ﺍﺨﺘﻴﺎﺭﻩ ﻴﻘﻭﻡ ﻫﺫﺍ ﺍﻟﻜﻭﺩ ﺒﺘﻨﻔﻴﺫ ﺍﻟﻌﻤﻠﻴﺔ‪.‬‬
‫‪ -٢‬ﻻﺤﻅ ﺃﻨﻨﺎ ﻫﻨﺎ ﻁﺒﻘﻨﺎ ﺠﻤﻴﻊ ﺍﻟﻌﻤﻠﻴﺎﺕ ﺍﻷﺴﺎﺴﻴﺔ‪.‬‬
‫‪ -٣‬ﺘﺴﺘﻁﻴﻊ ﻨﻘل ﺠﻤل ﺍﻟﺸﺭﻁ ﺍﻟﻤﺘﻌﻠﻘﺔ ﺒﺎﻟﺘﺄﻜﺩ ﻤﻥ ﺃﻥ ﻫﻨﺎﻙ ﻤﺩﺨل ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﺇﻟﻰ ﺒﺩﺍﻴﺔ‬
‫ﺍﻹﺠﺭﺍﺀ ﻟﻜﻲ ﺘﻜﻭﻥ ﺸﺎﻤﻠﺔ ﻟﻠﺠﻤﻴﻊ‪.‬‬
‫‪ -٤‬ﻟﺭﺅﻴﺔ ﺍﻟﻨﻅﺎﻡ ﺒﻌﺩ ﺍﻟﺘﺸﻐﻴل ﺍﻨﻅﺭ ﺍﻟﺸﻜل )‪ (٣-٤‬ﻭﻻﺤﻅ ﺃﻨﻨﺎ ﺍﺨﺘﺭﻨﺎ ﺯﺭ ﺍﻻﺨﺘﻴﺎﺭ ﺍﻟﻤﺘﻌﻠﻕ‬
‫ﺒﺎﻟﺒﺤﺙ ﻓﻲ ﺴﻠﺴﻠﺔ ﺜﻡ ﺃﺩﺨﻠﻨﺎ ﺤﺭﻑ ‪ m‬ﺜﻡ ﻀﻐﻁﻨﺎ ﺯﺭ ﺍﻷﻤﺭ ﻓﻅﻬﺭ ﻟﻨﺎ ﺭﻗﻡ ‪ ٤‬ﻓﻲ ﺃﺩﺍﺓ‬
‫ﺍﻟﻌﻨﻭﺍﻥ ﻭﻫﻭ ﻤﺎ ﻴﻤﺜل ﻤﻭﻗﻊ ﺤﺭﻑ ‪.m‬‬
‫ﺸﻜل ‪ : ٣ -٤‬ﻨﻅﺎﻡ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺴﻼﺴل‬
‫‪68‬‬
‫ﻤﻘﺩﻤﺔ ﻋﻥ ‪ADO.NET‬‬
‫ﻤﺎ ﻫﻲ ‪ ADO.NET‬؟‬
‫ﻴﻤﻜﻥ ﺘﻌﺭﻴﻔﻬﺎ ﺒﺄﻨﻬﺎ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﻔﺌﺎﺕ–‪ -CLASSES‬ﻟﻠﺘﻌﺎﻤل ﻤﻊ ﻤﺼﺎﺩﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻓﺈﺫﺍ‬
‫ﺃﺭﺩﺕ ﺍﻻﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﻤﺎ ‪ -‬ﻭ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺒﻴﺎﻨﺎﺕ ﻤﻭﺠﻭﺩﺓ ﻓﻴﻬﺎ ﺃﻭ ﺇﻀﺎﻓﺔ ﺒﻴﺎﻨﺎﺕ ﺠﺩﻴﺩﺓ‬
‫ﻤﺜل ﺃﻭﺭﺍﻜل ﺃﻭ ﺃﻜﺴﻴﺱ ﻤﻥ ﺨﻼل ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻓﺴﻭﻑ ﺘﻘﻭﻡ ﺒﺫﻟﻙ ﻤﻥ ﺨﻼل‬ ‫ﻟﻬﺎ‪-‬‬
‫‪ .ADO.NET‬ﺘﻡ ﺘﺼﻤﻴﻡ ‪ ADO.NET‬ﻓﻲ ﺍﻷﺴﺎﺱ ﻟﻠﻌﻤل ﻤﻊ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﻜﻥ ﺘﻌﻤل ﻤﻊ‬
‫ﻏﻴﺭﻫﺎ ﻤﻥ ﻤﺼﺎﺩﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ ،‬ﻟﺫﺍ ﻴﻤﻜﻥ ﺍﻟﻘﻭل ﺒﺄﻥ ‪ ADO.NET‬ﻴﻤﻜﻥ ﺃﻥ ﺘﺘﻌﺎﻤل ﻤﻊ ﺍﻷﻨﻭﺍﻉ‬
‫ﺍﻟﺘﺎﻟﻴﺔ ﻤﻥ ﻤﺨﺎﺯﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪:‬‬
‫‪ -١‬ﺍﻟﻤﺨﺎﺯﻥ ﻏﻴﺭ ﺍﻟﻤﺘﻨﺎﺴﻘﺔ ‪ :‬ﻭﻫﻲ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﻻ ﻴﻭﺠﺩ ﻟﻬﺎ ﺘﺭﺘﻴﺏ ﻤﺤﺩﺩ ﻤﺜل ﻤﻠﻑ ﻨﺼﻲ‪.‬‬
‫‪ -٢‬ﺍﻟﻤﺨﺎﺯﻥ ﺍﻟﻤﺘﻨﺎﺴﻘﺔ ﻏﻴﺭ ﺍﻟﻤﺘﺩﺭﺠﺔ )‪ : (CSV‬ﻭﻫﻲ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﻔﺼﻭﻟﺔ ﺒﻔﺎﺼﻠﺔ ﻤﺜل ﻤﻠﻔﺎﺕ‬
‫‪.ActiveDirectory ،Excel‬‬
‫‪ -٣‬ﺍﻟﻤﺨﺎﺯﻥ ﺍﻟﻬﺭﻤﻴﺔ ‪:‬ﻭﻫﻲ ﻤﻠﻔﺎﺕ ﺘﺨﺯﻥ ﻓﻴﻬﺎ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺄﺴﻠﻭﺏ ﻫﺭﻤﻲ‪ ،‬ﻟﻌل ﻤﻥ ﺃﺒﺭﺯ ﺍﻷﻤﺜﻠﺔ‬
‫ﻤﻠﻔﺎﺕ ‪.XML‬‬
‫‪ -٤‬ﻤﺨﺎﺯﻥ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﺘﺭﺍﺒﻁﺔ ‪ :‬ﻤﺜل ﺃﻭﺭﺍﻜل‪.MySQL ،SQLServer ،‬‬
‫ﻤﻭﻗﻊ ‪ ADO.NET‬ﻤﻥ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ‪:‬‬

‫ﺘﻌﺘﺒﺭ ‪ ADO.NET‬ﺠﺯﺀ ﻤﻥ ﺇﻁﺎﺭ ﺍﻟﻌﻤل –‪ -Framework‬ﻭﻫﻭ ﻤﺎﻴﺠﻌﻠﻬﺎ ﺘﺸﺎﺭﻜﻪ ﺒﻌﺽ‬
‫ﺍﻟﻤﺯﺍﻴﺎ ﻤﺜل ﺘﺠﻤﻴﻊ ﺍﻟﻤﻬﻤﻼﺕ ‪ - garbage collection-‬ﻭ ﺍﻟﺘﺼﻤﻴﻡ ﺍﻟﺸﻴﺌﻲ ‪OO -‬‬
‫‪ -design‬ﻭ ﺩﻋﻡ ﻤﺘﻌﺩﺩ ﻟﻠﻐﺎﺕ‪ . multi-language‬ﻤﺭ ﻓﻲ ﺍﻟﻔﺼل ﺍﻟﻤﺘﻌﻠﻕ ﺒﺎﻟﻤﻘﺩﻤﺔ ﻋﻥ ﺒﻴﺌﺔ‬
‫ﺍﻟﺩﻭﺕ ﻨﺕ ﺘﻌﺭﻴﻑ ﺍﻟﺒﻴﺌﺔ ﺍﻟﻤﺘﺼﻠﺔ ﻭ ﺍﻟﺒﻴﺌﺔ ﻏﻴﺭ ﺍﻟﻤﺘﺼﻠﺔ ﻭ ﻴﻤﻜﻨﻨﺎ ﺃﻥ ﻨﻘﻭل ﺒﺄﻥ ‪ADO.NET‬‬
‫ﻤﺼﻤﻤﺔ ﻟﻠﻌﻤل ﻤﻊ ﺍﻟﺒﻴﺌﺔ ﺍﻟﻤﺘﺼﻠﺔ ﻭ ﺍﻟﺒﻴﺌﺔ ﻏﻴﺭ ﺍﻟﻤﺘﺼﻠﺔ‪ .‬ﻭﺤﻴﺙ ﺇﻥ ‪ ADO‬ﺘﻌﺘﺒﺭ ﺠﺯﺀ ﻤﻥ‬
‫ﺇﻁﺎﺭ ﺍﻟﻌﻤل ﻓﻬﻲ ﻤﻘﺴﻤﺔ ﺇﻟﻰ ﺍﻤﺘﺩﺍﺩﺍﺕ ﻤﻨﻁﻘﻴﺔ ‪ ،‬ﻭ ﻗﺩ ﺘﻡ ﺒﻨﺎﺀ ‪ ADO‬ﻓﻲ ﺍﻹﻤﺘﺩﺍﺩ‬
‫‪ System.data‬ﻜﻤﺎ ﻴﺠﺩﺭ ﺍﻟﺘﻨﻭﻴﻪ ﺃﻥ ﻫﻨﺎﻙ ﺠﺯﺀ ﻤﻥ ‪ ADO‬ﻴﻘﻊ ﻓﻲ ﺍﻤﺘﺩﺍﺩ ﺁﺨﺭ ﻫﻭ‬
‫‪ System.xml‬ﺍﻨﻅﺭ ﺍﻟﺸﻜل ﺍﻟﺘﺎﻟﻲ ‪.‬‬
‫‪System.Data‬‬
‫‪.SqlTypes‬‬ ‫‪.SqlClient .Common‬‬ ‫‪.OleDb‬‬
‫‪126‬‬
‫ﺍﻟﻔﺭﻕ ﺒﻴﻥ ‪ ADO.NET‬ﻭ ‪:ADO‬‬
‫ﺤﺼل ﻫﻨﺎﻙ ﺘﻁﻭﺭ ﻀﺨﻡ ﻤﻥ ﺍﻹﺼﺩﺍﺭ ﺍﻟﺴﺎﺒﻕ ﻓﻲ ‪ ADO‬ﺇﻟﻰ ﺍﻹﺼﺩﺍﺭ ﺍﻟﺤﺎﻟﻲ ‪ADO.NET‬‬
‫ﻭﻻ ﻨﺒﺎﻟﻎ ﺇﺫﺍ ﻗﻠﻨﺎ ﺇﻥ ‪ ADO.NET‬ﺘﻌﺘﺒﺭ ﺘﻘﻨﻴﺔ ﺠﺩﻴﺩﺓ ﻭ ﻟﻴﺴﺕ ﺇﺼﺩﺍﺭﺍ ﺠﺩﻴﺩﺍ ﻟﺴﺎﻟﻔﺘﻬﺎ ‪.ADO‬‬
‫ﻭﺇﻟﻴﻙ ﺒﻌﺽ ﺍﻟﻔﺭﻭﻕ ﺒﻴﻥ ﺍﻹﺼﺩﺍﺭﻴﻥ‪.‬‬
‫‪ADO.NET‬‬ ‫‪ADO‬‬ ‫ﻭﺠﻪ ﺍﻟﻤﻘﺎﺭﻨﺔ‬
‫ﺩﻋﻡ ﻗﻭﻱ‬ ‫ﻏﻴﺭ ﻤﻭﺠﻭﺩ‬ ‫ﺩﻋﻡ ‪xml‬‬
‫ﻨﻅﺭﺍ ﻷﻥ ‪DATASET‬‬ ‫ﻫﻨﺎﻙ ﻋﺎﺌﻕ ﻟﻨﻘل ‪ ADO‬ﻤﻥ‬ ‫ﻨﻘل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﺨﻼل ﺍﻟﺠﺩﺍﺭ‬
‫ﺘﺩﻋﻡ ‪ XML‬ﻓﻼ ﻴﻭﺠﺩ‬ ‫ﺨﻼل ﺍﻟﺠﺩﺍﺭ ﺍﻟﻨﺎﺭﻱ‪.‬‬ ‫ﺍﻟﻨﺎﺭﻱ‬
‫ﻤﺸﻜﻠﺔ ﻓﻲ ﻨﻘل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ‬
‫ﺨﻼل ﺍﻟﺠﺩﺍﺭ ﺍﻟﻨﺎﺭﻱ‪.‬‬
‫ﺍﻟﺒﻴﺌﺔ ﻏﻴﺭ ﺍﻟﻤﺘﺼﻠﺔ ﺘﺴﺎﻋﺩ‬ ‫ﻴﻭﺠﺩ ﻤﺸﻜﻠﺔ ﻓﻲ ﺍﻟﺘﻭﺴﻊ ﻷﻥ‬ ‫ﺍﻟﺘﻭﺴﻊ‬
‫ﻋﻠﻰ ﺍﻻﺸﺘﺭﺍﻙ ﻓﻲ ﺍﻻﺘﺼﺎل‬ ‫ﺍﻻﺘﺼﺎل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻴﺘﻡ‬
‫ﻭﻤﻥ ﺜﻡ ﺇﻤﻜﺎﻨﻴﺔ ﺘﻭﺴﻊ ﻜﺒﻴﺭﺓ‪.‬‬ ‫ﺤﻔﻅﻪ ﻟﻤﺩﺓ ﻁﻭﻴﻠﺔ‪.‬‬
‫‪ DataSet‬ﺘﺤﻭﻱ ﻋﺩﺩ ﻏﻴﺭ‬ ‫‪ Recordset‬ﺘﺤﻭﻱ ﻋﻠﻰ ﺠﺩﻭل‬ ‫ﺘﻤﺜﻴل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﺍﻟﺫﺍﻜﺭﺓ‬
‫ﻤﺤﺩﺩ ﻤﻥ ﺍﻟﺠﺩﺍﻭل ﻓﻲ ﻨﻔﺱ‬ ‫ﻭﺍﺤﺩ ﻓﻲ ﻨﻔﺱ ﺍﻟﻭﻗﺕ‪.‬‬
‫ﺍﻟﻭﻗﺕ‬
‫ﺘﻤﻜﻥ ﻤﻥ ﻋﻤل ﺍﻟﻌﻼﻗﺎﺕ ﺒﻌﺩ‬ ‫ﺘﺘﻁﻠﺏ ﺭﺒﻁ ﺍﻟﺠﺩﺍﻭل ﻗﺒل‬ ‫ﺍﻟﻌﻼﻗﺎﺕ ﺒﻴﻥ ﻋﺩﺓ ﺠﺩﺍﻭل‬
‫ﺇﺤﻀﺎﺭﻫﺎ ﻤﻥ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫ﺇﺤﻀﺎﺭﻫﺎ ﻤﻥ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫ﻤﻥ ﺨﻼل ‪.DataRelation‬‬
‫ﻴﺘﻡ ﺍﻟﻤﺭﻭﺭ ﻋﻠﻰ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫ﻴﺘﻡ ﺍﻟﻤﺭﻭﺭ ﻋﻠﻰ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺸﻜل‬ ‫ﺍﻟﻤﺭﻭﺭ ﻋﻠﻰ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ﺒﺸﻜل ﻏﻴﺭ ﺘﺴﻠﺴﻠﻲ‪.‬‬ ‫ﺘﺴﻠﺴﻠﻲ ﺩﺍﺨل ‪.Recordset‬‬
‫ﻤﻬﻴﺄﺓ ﻤﻥ ﺨﻼل ‪ Dataset‬ﻭ‬ ‫ﻻ ﻴﻭﺠﺩ ﺩﻋﻡ ﺠﻴﺩ‪.‬‬ ‫ﺍﻟﺒﻴﺌﺔ ﻏﻴﺭ ﺍﻟﻤﺘﺼﻠﺔ‬
‫‪.DataAdaptor‬‬
‫‪127‬‬
‫ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺸﻴﺌﻲ ﻟـ ‪: ADO.NET‬‬
‫ﻴﺘﻜﻭﻥ ﺍﻟﻨﻤﻭﺫﺝ ﺍﻟﺸﻴﺌﻲ –‪ -ObjectModel‬ﻟـ ‪ ADO.NET‬ﻤﻥ ﺠﺯﺃﻴﻥ ﻫﻤﺎ‬

‫‪ -١‬ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪.Dataset‬‬
‫‪ -٢‬ﻤﺯﻭﺩﺍﺕ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪.net DataProvider Classes‬‬
‫ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪: Dataset‬‬
‫ﻭﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻷﻨﻅﻤﺔ ﺍﻟﺒﺭﻤﺠﻴﺔ ﺍﻟﺘﻲ ﺘﺴﻤﺢ ﺒﺄﻥ ﺘﺨﺯﻥ ﻓﻴﻬﺎ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻜﻤﺎ ﺘﺴﻤﺢ‬
‫ﺒﺈﺩﺍﺭﺓ ﻫﺫﻩ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻴﺠﺏ ﺃﻥ ﻨﻼﺤﻅ ﺃﻥ ‪ Dataset‬ﻻ ﺘﻌﺘﻤﺩ ﻋﻠﻰ ﻤﺼﺩﺭ ﺒﻴﺎﻨﺎﺕ ﻤﻌﻴﻥ ﻤﻤﺎ‬
‫ﻴﻭﻓﺭ ﺇﻤﻜﺎﻨﻴﺔ ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﻤﻊ ﺃﻱ ﻤﺼﺩﺭ ﺒﻴﺎﻨﺎﺕ ﻭﺴﻭﻑ ﻴﺄﺘﻲ ﻓﺼل ﻜﺎﻤل ﺨﺎﺹ ﺒﻤﺠﻤﻭﻋﺔ‬
‫ﻤﺯﻭﺩﺍﺕ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪: .net DataProvider Classes‬‬
‫ﻭﻫﻲ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﻔﺌﺎﺕ ﺘﺩﻋﻡ ﻤﺼﺩﺭ ﺒﻴﺎﻨﺎﺕ ﻤﺤﺩﺩ ﻟﺫﻟﻙ ﻴﺠﺏ ﻜﺘﺎﺒﺔ ﻫﺫﻩ ﺍﻟﻤﺯﻭﺩﺍﺕ ﺨﺼﻴﺼﺎ ﻟﻬﺫﺍ‬
‫ﺍﻟﻤﺼﺩﺭ ﻭ ﺒﺎﻟﺘﺎﻟﻲ ﻟﻥ ﺘﻌﻤل ﻫﺫﻩ ﺍﻟﻤﺯﻭﺩﺍﺕ ﻤﻊ ﻤﺼﺩﺭ ﺁﺨﺭ‪ .‬ﻭ ﺘﻭﻓﺭ ﻫﺫﻩ ﺍﻟﻤﺯﻭﺩﺍﺕ ﺍﻟﻘﺩﺭﺓ ﻋﻠﻰ‬
‫ﺍﻹﺘﺼﺎل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﺍﺴﺘﻌﺎﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻨﻬﺎ ﻭ ﺘﺤﺩﻴﺜﻬﺎ‪ .‬ﻴﻭﺠﺩ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﻫﺫﻩ ﺍﻟﻤﺯﻭﺩﺍﺕ ﻤﺜل‬
‫‪ .Sql Server .net Data Provider‬ﺍﻨﻅﺭ ﺍﻟﺸﻜل)‪. (١-١٢‬‬
‫ﺷﻜﻞ ‪ : ١-١٢‬اﻟﻨﻤﻮذج اﻟﺸﻴﺌﻲ ﻟــ ‪ADO.NET‬‬

‫‪Managed Provider‬‬
‫‪DataAdapter‬‬ ‫‪DataSet‬‬
‫‪C lients / G rids / Form s‬‬
‫‪Connection‬‬ ‫‪Command‬‬ ‫‪Connection‬‬

‫‪DataTables‬‬
‫‪DataReader‬‬
‫‪128‬‬
‫ﺘﻘﻭﻡ ‪ ADO.NET‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﻤﺯﻭﺩﺍﺕ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﻼﺘﺼﺎل ﺒﻤﺼﺎﺩﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﻤﻥ ﺜﻡ ﺍﺴﺘﺭﺠﺎﻉ ﻭ‬

‫ﺘﻌﺩﻴل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﺫﻟﻙ ﺘﻤﺜل ﻫﺫﻩ ﺍﻟﻤﺯﻭﺩﺍﺕ ﻁﺒﻘﺔ ﺨﻔﻴﻔﺔ ﺒﻴﻥ ﻤﺎ ﺘﻜﺘﺒﻪ ﻤﻥ ﺸﻔﺭﺍﺕ ﻭ ﻤﺼﺎﺩﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫ﺃﻨﻭﺍﻉ ﻤﺯﻭﺩﺍﺕ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪:‬‬

‫ﻴﻭﺠﺩ ﻨﻭﻋﻴﻥ ﻤﻥ ﻤﺯﻭﺩﺍﺕ ﻟﻠﺒﻴﺎﻨﺎﺕ ﻭﻫﻲ ‪:‬‬
‫‪-١‬ﻤﺯﻭﺩ ‪ : Oledb‬ﻭﻫﻭ ﻨﻭﻉ ﻋﺎﻡ ﻟﻼﺘﺼﺎل ﺒﻤﺼﺎﺩﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﺨﺘﻠﻔﺔ‪ ،‬ﺘﺴﺘﻁﻴﻊ ﻤﻥ ﺨﻼل ‪oledb‬‬
‫ﺍﻻﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﺃﻭﺭﺍﻜل ﺃﻭ ‪ MySQL‬ﺃﻭ ﺃﻜﺴﺱ‪.‬‬
‫‪ -٢‬ﻤﺯﻭﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﺩﺍﺭ –‪ : -Managed Data Provider‬ﻭﻫﻭ ﺍﻟﻤﺯﻭﺩ ﺍﻟﺫﻱ ﺘﻡ ﺒﻨﺎﺌﻪ ﺨﺼﻴﺼﺎ‬
‫ﻟﻠﻌﻤل ﻤﻊ ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﻤﺤﺩﺩﺓ‪ .‬ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻤﻥ ﺍﻟﻤﺯﻭﺩﺍﺕ ﻴﺴﻤﻰ ﻤﺯﻭﺩ ﺃﺼﻠﻲ – ‪Native‬‬
‫‪ -Provider‬ﻷﻨﻪ ﻴﻘﻭﻡ ﺒﻔﻌﺎﻟﻴﺔ ﺒﺎﻟﺘﻌﺎﻤل ﻤﻊ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﺒﻨﻲ ﻤﻥ ﺃﺠﻠﻬﺎ‪ .‬ﻭ ﻫﺫﺍ ﺍﻟﻨﻭﻉ ﻻ‬
‫ﻴﻤﻜﻥ ﺃﻥ ﻴﻌﻤل ﻤﻊ ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﻏﻴﺭ ﺍﻟﺘﻲ ﺒﻨﻲ ﻤﻥ ﺃﺠﻠﻬﺎ‪ .‬ﺍﻨﻅﺭ ﺍﻟﺸﻜل)‪(٢-١٢‬‬
‫ﺷﻜﻞ ‪ : ٢-١٢‬اﻻﺗﺼﺎل ﻳﻘﻮاﻋﺪ اﻟﺒﻴﺎﻧﺎت ﻣﻦ ﺧﻼل ﻣﺰودات اﻟﺒﻴﺎﻧﺎت‬

‫اﻟﻜﻮد اﻟﺨﺎص ﺑﻚ‬
‫‪OLE DB .NET‬‬ ‫‪SQL Client .NET‬‬ ‫‪ODBC .NET‬‬ ‫‪MySQL Client .NET‬‬
‫‪Data Provider‬‬ ‫‪Data Provider‬‬ ‫‪Data Provider‬‬ ‫‪Data Provider‬‬
‫‪OLE DB‬‬ ‫‪ODBC‬‬

‫‪Provider‬‬ ‫‪Driver‬‬
‫‪SQL Server‬‬
‫ﻤﺨﺯﻥ ﺒﻴﺎﻨﺎﺕ‬ ‫ﻣﺨﺰن ﺑﻴﺎﻧﺎت‬ ‫‪MySQL 4.0‬‬
‫‪/ MSDE‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻓﻲ ﺤﺎﻟﺔ ﺍﺨﺘﻴﺎﺭ ﻤﺯﻭﺩ ﺒﻴﺎﻨﺎﺕ ﺃﺼﻠﻲ ﻓﺈﻥ ﺍﻻﺘﺼﺎل ﺴﻴﻜﻭﻥ ﻤﺒﺎﺸﺭﺍ ﺒﻴﻥ ﺍﻟﻜﻭﺩ ﺍﻟﺫﻱ‬
‫ﺘﻜﺘﺒﻪ ﻭ ﺒﻴﻥ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﻴﻨﻤﺎ ﺘﻭﺠﺩ ﻁﺒﻘﺔ ﻋﻨﺩﻤﺎ ﺘﺴﺘﺨﺩﻡ ﺍﻟﻨﻭﻉ ﺍﻟﻌﺎﻡ ‪ ،Oledb‬ﺃﻭ ‪. ODBC‬‬
‫ﻋﻨﺩ ﺘﻬﻴﺌﺔ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻋﻠﻰ ﺤﺎﺴﺒﻙ ﻓﺈﻨﻪ ﻴﻭﺠﺩ ﻤﻌﻬﺎ ﻤﺯﻭﺩﺍ ﺒﻴﺎﻨﺎﺕ ﻫﻤﺎ ‪:‬‬
‫‪ -١‬ﺍﻟﻤﺯﻭﺩ ﺍﻟﻌﺎﻡ ‪.Oledb‬‬
‫‪ -٢‬ﻤﺯﻭﺩ ﺒﻴﺎﻨﺎﺕ ﺃﺼﻠﻲ ﻴﻌﻤل ﻤﻊ ‪.SQLServer‬‬
‫‪129‬‬
‫ﺇﺫﺍ ﺭﻏﺒﺕ ﺒﺈﻀﺎﻓﺔ ﻤﺯﻭﺩ ﺒﻴﺎﻨﺎﺕ ﺃﻭﺭﺍﻜل ﻗﻡ ﺒﺈﻨﺯﺍﻟﻪ ﺒﺎﻟﻤﺠﺎﻥ ﻤﻥ ﻤﻭﻗﻊ ﻤﺎﻴﻜﺭﻭﺴﻭﻓﺕ ﻭﻤﻥ ﺜﻡ ﻗﻡ‬
‫ﺒﺘﻬﻴﺌﺘﻪ ﻟﺘﺘﻡ ﻋﻤﻠﻴﺔ ﺇﻀﺎﻓﺘﻪ ﺇﻟﻰ ﺒﺎﻗﻲ ﺍﻟﻤﺯﻭﺩﺍﺕ ﺍﻟﻤﻭﺠﻭﺩﺓ‪.‬‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﺴﻭﻑ ﻴﻜﻭﻥ ﻤﺯﻭﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺨﺎﺹ ﺒﺄﻭﺭﺍﻜل ﻤﺘﻭﻓﺭﺍ ﻓﻲ ﻨﺴﺨﺔ ‪ ٢٠٠٣‬ﻤﻥ ﻓﻴﺠﻭﺍل‬
‫ﺴﺘﻭﺩﻴﻭ ﺩﻭﺕ ﻨﺕ ‪.‬‬
‫ﺘﻨﺩﺭﺝ ﻤﺯﻭﺩﺍﺕ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺘﺤﺕ ﻓﻀﺎﺀﺍﺕ ﺍﻷﺴﻤﺎﺀ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫‪System.Data.SqlClient‬‬
‫‪System.Data.OleDb‬‬
‫ﺍﻟﻤﺯﻭﺩ ﺍﻷﻭل ﻫﻭ ﺍﻟﻤﺯﻭﺩ ﺍﻷﺼﻠﻲ ﻟـ ‪ SQLServer‬ﺃﻤﺎ ﺍﻟﻤﺯﻭﺩ ﺍﻟﺜﺎﻨﻲ ﻓﻬﻭ ﺍﻟﻤﺯﻭﺩ ﺍﻟﻌﺎﻡ‪.‬‬
‫ﻤﻜﻭﻨﺎﺕ ﻤﺯﻭﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪:‬‬
‫ﺘﺘﻜﻭﻥ ﻤﺯﻭﺩﺍﺕ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﺃﺭﺒﻌﺔ ﻓﺌﺎﺕ –‪ -Classes‬ﺘﺒﺩﺃ ﺃﻭل ﺜﻼﺜﺔ ﺃﺤﺭﻑ ﻤﻨﻬﺎ ﺒﺎﺴﻡ ﺍﻟﻤﺯﻭﺩ‬
‫ﻭﻫﻲ ‪:‬‬
‫‪ -١‬ﻜﺎﺌﻥ ﺍﻻﺘﺼﺎل –‪ : -Connection‬ﺍﻟﻔﺌﺔ ﺍﻟﻤﺨﺼﺼﺔ ﻟﻼﺘﺼﺎل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻴﻨﺩﺭﺝ ﺘﺤﺕ‬
‫ﻓﻀﺎﺀﺍﺕ ﺍﻷﺴﻤﺎﺀ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪System.Data.OleDb.OleDbConnection‬‬
‫‪System.Data.SqlClient.SqlConnection‬‬
‫‪ -٢‬ﻜﺎﺌﻥ ﺍﻷﻤﺭ –‪ : -Command‬ﺍﻟﻔﺌﺔ ﺍﻟﻤﺨﺼﺼﺔ ﻟﺘﻨﻔﻴﺫ ﺃﻤﺭ ﻤﺎ ﻤﺜل ‪ :‬ﺘﻨﻔﻴﺫ ‪Stored‬‬

‫‪ Procedure‬ﻭﻤﺜل ﺘﻨﻔﻴﺫ ﻋﻤﻠﻴﺔ ﺍﻀﺎﻓﺔ ﺒﻴﺎﻨﺎﺕ‪ ،‬ﺘﺤﺕ ﻓﻀﺎﺀﺍﺕ ﺍﻷﺴﻤﺎﺀ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪System.Data.OleDb.OleDbCommand‬‬
‫‪System.Data.SqlClient.SqlCommand‬‬
‫‪ -٣‬ﻜﺎﺌﻥ ﻗﺎﺭﺉ ﺍﻟﺒﻴﺎﻨﺎﺕ –‪ : -DataReader‬ﺘﺴﺘﺨﺩﻡ ﻟﻠﻘﺭﺍﺀﺓ ﻓﻘﻁ ﻭ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻴﻤﻜﻥ ﻗﺭﺍﺀﺘﻬﺎ ﺇﻟﻰ‬
‫ﺍﻷﻤﺎﻡ ﻭ ﻻ ﻴﻤﻜﻥ ﺍﻟﺭﺠﻭﻉ ﻟﻠﺨﻠﻑ‪ ،‬ﺘﺴﺘﺨﺩﻡ ﻟﻺﺴﺘﻌﻼﻡ ﻭﺘﻌﺘﺒﺭ ﺫﺍﺕ ﺃﺩﺍﺀ ﻋﺎﻟﻲ ﺠﺩﺍ ‪ .‬ﺘﺤﺕ‬
‫ﻓﻀﺎﺀﺍﺕ ﺍﻷﺴﻤﺎﺀ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪130‬‬
-٤
System.Data.OleDb.OleDbDataReader
System.Data.SqlClient.SqlDataReader
– ‫ ﻫﻭ ﺍﻟﻜﺎﺌﻥ ﺍﻟﺫﻱ ﻴﻘﻭﻡ ﺒﺘﻌﺒﺌﺔ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬: -DataAdaptor– ‫ ﻤﻬﻴﺊ ﺍﻟﺒﻴﺎﻨﺎﺕ‬-٥

‫ ﻭﻜﺫﻟﻙ ﻴﻘﻭﻡ ﺒﺘﻨﻔﻴﺫ ﺍﻟﺘﻌﺩﻴﻼﺕ ﺍﻟﺘﻲ ﺃﺠﺭﻴﺕ ﻋﻠﻰ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻋﻜﺴﻬﺎ‬-Dataset
: ‫ ﻴﻨﺩﺭﺝ ﺘﺤﺕ ﻓﻀﺎﺀﺍﺕ ﺍﻷﺴﻤﺎﺀ ﺍﻟﺘﺎﻟﻴﺔ‬. .‫ﻋﻠﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
System.Data.OleDb.OleDbDataAdapter
System.Data.SqlClient.SqlDataAdapter
131
‫ﺍﻻﺘﺼﺎل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ﻟﻘﺭﺍﺀﺓ ﺃﻭ ﻜﺘﺎﺒﺔ ﺒﻴﺎﻨﺎﺕ ﻋﻠﻰ ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﻤﺎ ﻻﺒﺩ ﻓﻲ ﺍﻟﺒﺩﺍﻴﺔ ﻤﻥ ﺇﻨﺸﺎﺀ ﺍﻻﺘﺼﺎل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‪،‬‬
‫ﻭﻫﻭ ﻤﺎ ﻴﺘﻡ ﻤﻥ ﺨﻼل ﻜﺎﺌﻥ ﺍﻻﺘﺼﺎل –‪ .-Connection‬ﻭﻜﻤﺎ ﻤﺭ ﺒﻙ ﺴﺎﻟﻔﺎ ﻓﺈﻨﻪ ﺒﻨﺎﺀ ﻋﻠﻰ ﺍﺨﺘﻴﺎﺭﻙ‬
‫ﻟﻤﺯﻭﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺴﻭﻑ ﺘﻘﻭﻡ ﺒﺎﺴﺘﺨﺩﺍﻡ ﻜﺎﺌﻥ ﺍﻻﺘﺼﺎل ﺍﻟﺨﺎﺹ ﺒﺫﻟﻙ ﺍﻟﻤﺯﻭﺩ‪ .‬ﻭﻨﺭﻴﺩ ﻫﻨﺎ ﺃﻥ ﻨﺫﻜﺭﻙ ﺒﺄﻥ‬
‫ﻜﺎﺌﻥ ﺍﻻﺘﺼﺎل ﻴﻭﺠﺩ ﻓﻲ ﺍﻻﻤﺘﺩﺍﺩ ﺍﻟﺘﺎﻟﻲ‬
‫‪System.Data.OleDb‬‬
‫ﺴﻭﻑ ﻨﻘﻭﻡ ﺒﺎﻟﺘﻌﺎﻤل ﻓﻲ ﺠﻤﻴﻊ ﺍﻷﻤﺜﻠﺔ ﻤﻊ ﻤﺯﻭﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻌﺎﻡ ‪ Oledb‬ﻨﻅﺭﺍ ﻷﻨﻨﺎ ﺴﻭﻑ‬
‫ﻨﺴﺘﺨﺩﻡ ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﻤﺎﻴﻜﺭﻭﺴﻭﻓﺕ ﺃﻜﺴﺱ ﻭﻫﻭ ﻤﺎﻴﺘﻭﻓﺭ ﻓﻲ ﻤﻌﻅﻡ ﺍﻷﺠﻬﺯﺓ‪.‬‬
‫ﻟﻼﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﻤﺎ ﻻﺒﺩ ﻤﻥ ﺍﻋﻁﺎﺀ ﻜﺎﺌﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻌﻠﻭﻤﺎﺕ ﻜﺎﻓﻴﺔ ﻋﻥ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ‬
‫ﺘﺭﻴﺩ ﺃﻥ ﺘﺘﺼل ﺒﻬﺎ ﻤﺜل ﻤﻜﺎﻥ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﺍﺴﻡ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﻜﻠﻤﺔ ﺍﻟﻤﺭﻭﺭ ﻭ ﺍﻟﻜﻠﻤﺔ ﺍﻟﺴﺭﻴﺔ‬
‫ﻟﻠﺩﺨﻭل ﻟﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻥ ﻭﺠﺩ‪ .‬ﺍﺴﺘﺨﺩﻡ ﺨﺎﺼﻴﺔ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل –‪-Connection String‬‬
‫ﻻﻋﻁﺎﺀ ﻫﺫﻩ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ‪.‬‬
‫‪133‬‬
‫ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ﻤﺎ ﻫﻲ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل –‪: - ConnectionString‬‬ ‫‪.I‬‬
‫ﺘﻌﺘﺒﺭ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل ﺃﺤﺩ ﺨﺼﺎﺌﺹ ﻜﺎﺌﻥ ﺍﻻﺘﺼﺎل‪ ،‬ﻭﻴﻤﻜﻥ ﺘﻌﺭﻴﻔﻬﺎ ﺒﺄﻨﻬﺎ ﻋﺒﺎﺭﺓ ﻋﻥ ﻋﺩﺩ ﻤﻥ‬
‫ﺍﻟﻌﻭﺍﻤل –‪ -Parameters‬ﺍﻟﻀﺭﻭﺭﻴﺔ ﻟﻼﺘﺼﺎل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺘﺨﺘﻠﻑ ﺒﻌﺽ ﻫﺫﻩ ﺍﻟﻌﻭﺍﻤل ﺒﻨﺎﺀ‬
‫ﻋﻠﻰ ﻤﺯﻭﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ .‬ﻴﺸﻤل ﺍﻟﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ﺃﻫﻡ ﺍﻟﻌﻭﺍﻤل ﻓﻲ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل ‪:‬‬
‫ﺍﻟﺸﺭﺡ‬ ‫ﺍﻟﻌﺎﻤل‬
‫ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻫﻲ ﺍﺴﻡ ﻤﺯﻭﺩ ‪ ole‬ﻟﻬﺫﺍ ﺍﻻﺘﺼﺎل ‪،‬ﻭﺘﺴﺘﺨﺩﻡ ﻓﻘﻁ ﻋﻨﺩﻤﺎ‬ ‫‪Provider‬‬
‫ﺘﻘﻭﻡ ﺒﺎﺴﺘﺨﺩﺍﻡ ﻤﺯﻭﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪.OLE DB‬‬
‫ﺍﺴﻡ ﺨﺎﺩﻡ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬ ‫‪DataSource‬‬
‫ﺍﺴﻡ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬ ‫‪Intial Catalog‬‬
‫ﻴﺤﺩﺩ ﻓﻴﻤﺎ ﺇﺫﺍ ﻜﺎﻥ ﺍﻻﺘﺼﺎل ﻤﺘﻜﺎﻤل ﺍﻟﺜﻘﺔ ﻤﻊ ﻭﻴﻨﺩﻭﺯ‪.‬‬ ‫‪Integrated Security‬‬
‫‪ ConnectionTimeout‬ﻭﻴﻤﺜل ﺍﻟﻭﻗﺕ ﺍﻟﺫﻱ ﺘﺘﻡ ﻓﻴﻪ ﻤﺤﺎﻭﻟﺔ ﺍﻻﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﺈﻥ ﻟﻡ ﻴﺘﻡ‬
‫ﺍﻻﺘﺼﺎل ﺨﻼل ﻫﺫﺍ ﺍﻟﻭﻗﺕ – ﺒﺎﻟﺜﺎﻨﻴﺔ – ﺘﻡ ﺍﺭﺠﺎﻉ ﺨﻁﺄ ﻭﺘﻡ ﺍﻓﺸﺎل‬
‫ﺍﻻﺘﺼﺎل ﻋﻠﻤﺎ ﺒﺄﻥ ﺍﻟﻭﻗﺕ ﺍﻻﻓﺘﺭﺍﻀﻲ ﻫﻭ ‪ ١٥‬ﺜﺎﻨﻴﺔ‪.‬‬
‫ﻜﻠﻤﺔ ﺍﻟﻌﺒﻭﺭ ﻟﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﺍﺴﻡ ﺍﻟﻤﺴﺘﺨﺩﻡ‪.‬‬ ‫‪UserID/Password‬‬
‫ﻭ ﺇﻟﻴﻙ ﻫﺫﺍ ﺍﻟﺠﺩﻭل ﺍﻟﺫﻱ ﻴﻌﻁﻲ ﺃﻤﺜﻠﺔ ﻋﻠﻰ ﺃﺴﻤﺎﺀ ﻤﺯﻭﺩﻱ ‪ ole‬ﺍﻟﺸﺎﺌﻌﻴﻥ‪.‬‬
‫ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت‬ ‫اﺳﻢ ﻣﺰود ‪Ole‬‬
‫‪Microsoft Access‬‬ ‫‪Microsoft.Jet.OLEDB.4.0‬‬
‫‪Microsoft SQL Server‬‬ ‫‪SQLOLEDB.1‬‬
‫‪Oracle‬‬ ‫‪MSDAORA.1‬‬
‫‪134‬‬
‫ﺃﻤﺜﻠﺔ ﻋﻠﻰ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل ‪:‬‬ ‫‪.II‬‬
‫‪ -١‬ﺴﻠﺴﻠﺔ ﻟﻼﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ‪SQLServer‬‬

‫‪Provider=sqloledb;Data Source=SQL Server DB;Initial‬‬
‫‪Catalog=Northwind;User ID=UserName;Password=password‬‬
‫‪ -٢‬ﺴﻠﺴﻠﺔ ﻟﻼﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﺃﻭﺭﺍﻜل‬

‫‪Provider=MSDAORA;Data Source=Oracle DB;User‬‬
‫‪ID=UserName;Password=password‬‬
‫‪ -٣‬ﺴﻠﺴﻠﺔ ﻟﻼﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﻤﺎﻴﻜﺭﻭﺴﻭﻓﺕ ﺃﻜﺴﺱ‬

‫;‪Provider=Microsoft.Jet.OLEDB.4.0;Data Source=c:\Mydb\db1.mdb‬‬
‫ﺇﺫﺍ ﻜﺎﻥ ﻤﻭﻗﻊ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﻨﻔﺱ ﺍﻟﻔﻬﺭﺱ –‪ -Directory‬ﺍﻟﺫﻱ ﺘﻘﻊ ﻓﻴﻪ ﺍﻟﺼﻔﺤﺔ ﺍﻟﺘﻲ‬
‫ﺘﺘﺼل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﺈﻨﻙ ﻻﺘﺤﺘﺎﺝ ﺇﻟﻰ ﻜﺘﺎﺒﺔ ﺍﻟﻤﻭﻗﻊ ﻜﺎﻤﻼ ﻭ ﺇﻨﻤﺎ ﻴﻜﻔﻲ ﺍﺴﻡ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪ .III‬ﻁﺭﻴﻘﺔ ﺴﻬﻠﺔ ﻟﺒﻨﺎﺀ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل‬
‫ﻗﺩ ﺘﻭﺍﺠﻪ ﺃﺤﻴﺎﻨﺎ ﻤﺸﻜﻠﺔ ﻓﻲ ﻜﺘﺎﺒﺔ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل ﻷﻨﻪ ﻤﻥ ﺍﻟﺼﻌﺏ ﺘﺫﻜﺭ ﻜﻴﻔﻴﺔ ﻜﺘﺎﺒﺘﻬﺎ ﺒﺩﻭﻥ ﺃﺨﻁﺎﺀ‬
‫ﻭ ﺒﺩﻭﻥ ﻨﺴﻴﺎﻥ ﺤﺭﻑ ﺃﻭ ﻓﺎﺼﻠﺔ‪ .‬ﻴﻭﺠﺩ ﻁﺭﻴﻘﺔ ﺴﻬﻠﺔ ﻹﻨﺸﺎﺀ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل‪ .‬ﻗﻡ ﺒﻤﺎ ﻴﻠﻲ ‪:‬‬
‫‪ -١‬ﻗﻡ ﺒﺈﻨﺸﺎﺀ ﻤﻠﻑ ﻨﺼﻲ ‪ TextFile‬ﻭﺍﻋﻁﻪ ﺍﺴﻡ ‪.MyConnString.txt‬‬
‫‪ -٢‬ﻏﻴﺭ ﺍﻤﺘﺩﺍﺩﻩ ﻤﻥ ‪ txt‬ﺇﻟﻰ ‪) UDL‬ﺍﺨﺘﺼﺎﺭ ‪.(Universal Data Link‬‬
‫‪ -٣‬ﺍﻨﻘﺭ ﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺍﻟﻤﻠﻑ ﻟﻴﻅﻬﺭ ﻟﻙ ﺍﻟﺸﻜل)‪(١-١٣‬‬
‫‪ -٤‬ﺍﺨﺘﺭ ﺸﺭﻴﻁ ﻤﺯﻭﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ Provider‬ﺜﻡ ﺍﺨﺘﺭ ﺍﻟﻤﺯﻭﺩ ﺍﻟﺨﺎﺹ ﺒﺄﻜﺴﺱ ﻭﻫﻭ‬
‫‪Microsoft.Jet.OLEDB.4‬‬
‫‪ -٥‬ﺍﺨﺘﺭ ﺸﺭﻴﻁ ‪. Connection‬‬
‫‪ -٦‬ﻗﻡ ﺒﺎﺨﺘﻴﺎﺭ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﺘﺭﻴﺩ ﺃﻥ ﺘﺒﻨﻲ ﻟﻬﺎ ﺴﻠﺴﻠﺔ ﺍﺘﺼﺎل‪.‬‬
‫‪135‬‬
‫ﺸﻜل ‪ : ١-١٣‬ﺍﺨﺘﻴﺎﺭ ﻤﺯﻭﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫‪-٧‬ﺍﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ﻤﻭﺍﻓﻕ‪.‬‬

‫‪-٨‬ﺍﺫﻫﺏ ﺇﻟﻰ ﺍﻟﻤﻠﻑ ‪ MyConnString.udl‬ﻭﺍﻓﺘﺤﻪ ﺒﻭﺍﺴﻁﺔ ‪ .NotePad‬ﻟﻴﻅﻬﺭ ﻟﻙ‬
‫ﺍﻟﺸﻜل)‪ ،(٢-١٣‬ﺍﺒﺘﺩﺍﺀ ﻤﻥ ﻜﻠﻤﺔ ‪ Provider‬ﻴﻤﺜل ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل‪.‬‬
‫ﺸﻜل ‪ : ٢-١٣‬ﻻﺤﻅ ﺃﻨﻪ ﺘﻡ ﺒﻨﺎﺀ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل‬
‫ﻓﺘﺢ ﻭ ﺍﻏﻼﻕ ﺍﻻﺘﺼﺎل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‬

‫ﻟﻔﺘﺢ ﺍﻻﺘﺼﺎل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﺴﺘﺨﺩﻡ ﺍﻟﻁﺭﻴﻘﺔ ‪ Open‬ﻭﻫﻲ ﺃﺤﺩ ﻁﺭﻕ ﻜﺎﺌﻥ ﺍﻻﺘﺼﺎل‪ .‬ﻭ ﻹﻏﻼﻕ‬
‫ﺍﻻﺘﺼﺎل ﺍﺴﺘﺨﺩﻡ ﺍﻟﻁﺭﻴﻘﺔ ‪ Close‬ﺃﻭ ‪ Dispose‬ﻭﺴﻭﻑ ﻴﺄﺘﻲ ﺍﻟﻔﺭﻕ ﺒﻴﻥ ﺍﻟﻁﺭﻴﻘﺘﻴﻥ‪.‬‬
‫‪136‬‬
‫ﻭ ﻟﻨﺄﺨﺫ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ‪:‬‬

‫)(‪Dim con As New OleDb.OleDbConnection‬‬
‫_ & "=‪con.ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source‬‬
‫"‪"C:\TelDir.mdb;Persist Security Info=False‬‬
‫)(‪con.Open‬‬
‫‪. . . . .‬‬
‫‪con.Close‬‬

‫‪ -١‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻷﻭل ﺃﻋﻠﻨﺎ ﻋﻥ ﻜﺎﺌﻥ ﺍﺘﺼﺎل ‪ Con‬ﻤﻥ ﻨﻭﻉ ‪.oledb‬‬
‫‪ -٢‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻨﻲ ﻗﻤﻨﺎ ﺒﺘﻌﺭﻴﻑ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل ﻭﻫﻲ ﻜﻤﺎ ﺘﻼﺤﻅ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ‬
‫ﺒﻴﺎﻨﺎﺕ ﺨﺎﺼﺔ ﺒﻤﺎﻴﻜﺭﻭﺴﻭﻓﺕ ﺃﻜﺴﺱ‪.‬‬
‫‪ -٣‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻟﺙ ﻗﻤﻨﺎ ﺒﻔﺘﺢ ﺍﻻﺘﺼﺎل‪.‬‬
‫‪ -٤‬ﺍﻟﻨﻘﺎﻁ ﻜﻨﺎﻴﺔ ﻋﻥ ﻋﻤﻠﻴﺎﺕ ﻨﻘﻭﻡ ﺒﻬﺎ ﻋﻠﻰ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪ -٥‬ﺃﺨﻴﺭﺍ ﺃﻏﻠﻘﻨﺎ ﺍﻻﺘﺼﺎل ﻤﻥ ﺨﻼل ﺍﻟﻁﺭﻴﻘﺔ ‪.Close‬‬
‫ﻁﺭﻕ ﻓﺘﺢ ﻭ ﺇﻏﻼﻕ ﺍﻻﺘﺼﺎل‬

‫ﺘﻭﺠﺩ ﻫﻨﺎﻙ ﻁﺭﻴﻘﺘﺎﻥ ﻟﻔﺘﺢ ﻭ ﺇﻏﻼﻕ ﺍﻻﺘﺼﺎل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪:‬‬
‫‪ -١‬ﻓﺘﺢ ﻭﺇﻏﻼﻕ ﺍﻻﺘﺼﺎل ﻅﺎﻫﺭﻴﺎ ‪ :‬ﻭﻨﻌﻨﻲ ﺒﻪ ﺃﻥ ﺘﻘﻭﻡ ﺒﺎﺴﺘﺨﺩﺍﻡ ﻭﻅﻴﻔﺔ ﻓﺘﺢ ﻭﺇﻏﻼﻕ ﺍﻻﺘﺼﺎل‬
‫ﺒﺸﻜل ﻅﺎﻫﺭ ﻓﻲ ﺍﻟﻜﻭﺩ‪ .‬ﻭ ﺘﻌﺘﺒﺭ ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﻁﺭﻴﻘﺔ ﻤﻔﻀﻠﺔ ﻟﻸﺴﺒﺎﺏ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ .I‬ﺴﻬﻭﻟﺔ ﻗﺭﺍﺀﺓ ﺍﻟﻜﻭﺩ‪ .‬ﺤﻴﺙ ﻴﻅﻬﺭ ﺒﺸﻜل ﻭﺍﻀﺢ ﻤﻜﺎﻥ ﻓﺘﺢ ﻭ ﺇﻏﻼﻕ ﺍﻻﺘﺼﺎل‬
‫‪ .II‬ﺘﺴﺎﻋﺩ ﻋﻠﻰ ﻤﺘﺎﺒﻌﺔ ﺍﻷﺨﻁﺎﺀ‬
‫ﻤﻼﺤﻅﺔ ‪ :‬ﻓﻲ ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ‪ ،‬ﻭﻷﻨﻙ ﺘﻘﻭﻡ ﺒﻔﺘﺢ ﻭ ﺇﻏﻼﻕ ﺍﻻﺘﺼﺎل ﺒﻨﻔﺴﻙ ﻴﺘﻭﺠﺏ ﻋﻠﻴﻙ ﺇﻏﻼﻕ‬
‫ﺍﻻﺘﺼﺎل ﻜﻠﻤﺎ ﺍﻨﺘﻬﻴﺕ ﻤﻨﻪ ﻟﻸﺴﺒﺎﺏ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ .a‬ﺃﻜﺜﺭ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﻬﺎ ﻋﺩﺩ ﻤﺤﺩﻭﺩ ﻤﻥ ﺍﻻﺘﺼﺎﻻﺕ‪.‬‬
‫‪ .b‬ﺘﺭﻙ ﺍﻻﺘﺼﺎل ﻤﻔﺘﻭﺤﺎ ﻴﺴﺘﻬﻠﻙ ﻤﻭﺍﺭﺩ ﻜﺒﻴﺭﺓ ﺠﺩﺍ‪.‬‬
‫ﻟﻠﺘﺄﻜﺩ ﻤﻥ ﺤﺎﻟﺔ ﺍﻻﺘﺼﺎل ﻫل ﻫﻭ ﻤﻔﺘﻭﺡ ﺃﻭ ﻤﻐﻠﻕ ﺍﺴﺘﺨﺩﻡ ﺨﺎﺼﻴﺔ ‪ State‬ﻜﻤﺎ ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ‬
‫‪137‬‬
‫)‪if (ConnectionObject.State = ConnectionState.Open‬‬

‫‪ -٢‬ﻓﺘﺢ ﻭ ﺇﻏﻼﻕ ﺍﻻﺘﺼﺎل ﺒﺎﻁﻨﻴﺎ ‪ :‬ﻭﻫﻭ ﺃﻥ ﻴﻘﻭﻡ ﻤﻬﻲﺀ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﻔﺘﺢ ﺍﻻﺘﺼﺎل ﻋﻨﺩ ﺘﻨﻔﻴﺫ‬
‫ﻋﻤﻠﻴﺔ ﻤﺎ‪ ،‬ﺜﻡ ﻴﻘﻭﻡ ﺒﺈﻏﻼﻕ ﺍﻻﺘﺼﺎل ﻋﻨﺩ ﺍﻨﺘﻬﺎﺌﻪ ﻤﻥ ﺍﻟﻌﻤﻠﻴﺔ‪ .‬ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﻻ ﺘﻘﻭﻡ‬
‫ﺒﺎﺴﺘﺨﺩﺍﻡ ﻭﻅﻴﻔﺘﻲ ﻓﺘﺢ ﻭ ﺇﻏﻼﻕ ﺍﻻﺘﺼﺎل ﺒل ﻴﻘﻭﻡ ﻤﻬﻲﺀ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺫﻟﻙ ﻭﺫﻟﻙ ﻋﻨﺩﻤﺎ ﺘﺴﺘﺨﺩﻡ‬
‫ﺇﺤﺩﻯ ﺍﻟﺩﺍﻟﺘﻴﻥ ﺍﻟﺘﺎﻟﻴﺘﻴﻥ ‪ Update ،Fill‬ﺘﻘﻭﻡ ﺍﻟﺩﺍﻟﺔ ﺒﺎﻟﺘﺄﻜﺩ ﻤﻥ ﻭﺠﻭﺩ ﺍﺘﺼﺎل ﻤﻔﺘﻭﺡ ﺒﻘﺎﻋﺩﺓ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﺘﺴﺘﺨﺩﻤﻪ ﺃﻭ ﺘﻘﻭﻡ ﺒﻔﺘﺢ ﺍﺘﺼﺎل ﺜﻡ ﺇﻏﻼﻗﻪ‪.‬‬
‫ﻋﻤﻠﻴﺘﺎ ﻓﺘﺢ ﻭ ﺍﻏﻼﻕ ﺍﻻﺘﺼﺎل ﻅﺎﻫﺭﻴﺎ ﻭ ﺒﺎﻁﻨﻴﺎ ﺘﻌﺘﻤﺩ ﻋﻠﻰ ﻨﻭﻉ ﺍﻟﺒﻴﺌﺔ ﺍﻟﺘﻲ ﺘﺴﺘﺨﺩﻤﻬﺎ‪ ،‬ﻫل‬
‫ﻫﻲ ﺒﻴﺌﺔ ﻤﺘﺼﻠﺔ ﺃﻭ ﻏﻴﺭ ﻤﺘﺼﻠﺔ‪ .‬ﺍﻟﻔﺘﺢ ﺍﻟﻅﺎﻫﺭﻱ ﺨﺎﺹ ﺒﺎﻟﺒﻴﺌﺔ ﺍﻟﻤﺘﺼﻠﺔ ﻭ ﺍﻟﻔﺘﺢ ﺍﻟﺒﺎﻁﻨﻲ ﺨﺎﺹ‬
‫ﺒﺎﻟﺒﻴﺌﺔ ﻏﻴﺭ ﺍﻟﻤﺘﺼﻠﺔ‪.‬‬
‫ﻤﻌﺎﻟﺠﺔ ﺍﺴﺘﺜﻨﺎﺀﺍﺕ ﺍﻻﺘﺼﺎل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‬

‫ﻋﻨﺩ ﺍﻻﺘﺼﺎل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻗﺩ ﺘﻅﻬﺭ ﺒﻌﺽ ﺍﻻﺴﺘﺜﻨﺎﺀﺍﺕ ﺍﻟﺘﺸﻐﻴﻠﻴﺔ‪ ،‬ﺒﻌﻀﻬﺎ ﻤﺘﻭﻗﻊ ﻭ ﺍﻟﺒﻌﺽ‬
‫ﺍﻵﺨﺭ ﻏﻴﺭ ﻤﺘﻭﻗﻊ‪ .‬ﺘﺘﻡ ﻤﻌﺎﻟﺠﺔ ﺍﻷﺨﻁﺎﺀ ﺍﻟﺘﺸﻐﻴﻠﻴﺔ ﻤﻥ ﺨﻼل ﻋﺒﺎﺭﺓ ‪ .Try Catch‬ﻴﻤﻜﻥ ﺘﻌﺭﻴﻑ‬
‫ﺍﻻﺴﺘﺜﻨﺎﺀ –‪ -Exception‬ﺒﺄﻨﻪ ﺇﻤﺎ ﺨﻁﺄ ﺃﻭ ﺃﺩﺍﺀ ﻏﻴﺭ ﻤﺘﻭﻗﻊ ﺇﻤﺎ ﻤﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻨﻔﺴﻪ ﺃﻭ ﻤﻥ ﺒﻴﺌﺔ‬
‫ﺘﺸﻐﻴل ﺍﻟﺒﺭﻨﺎﻤﺞ‪ .‬ﻅﻬﺭ ﺃﺴﻠﻭﺏ ﺠﺩﻴﺩ ﻟﻤﻌﺎﻟﺠﺔ ﺍﻻﺴﺘﺜﻨﺎﺀﺍﺕ ﻓﻲ ﺍﻟﺩﻭﺕ ﻨﺕ ﻤﻊ ﺍﻟﻌﻠﻡ ﺃﻨﻪ ﻟﻡ ﻴﻜﻥ‬
‫ﻤﻭﺠﻭﺩﺍ ﻓﻲ ﺍﻻﺼﺩﺍﺭ ﺍﻟﺴﺎﺒﻕ ﻤﻥ ﻓﻴﺠﻭﺍل ﺒﻴﺴﻙ ﻭ ﺍﻟﺫﻱ ﻜﺎﻥ ﻴﻌﺎﻟﺞ ﺍﻷﺨﻁﺎﺀ ﻤﻥ ﺨﻼل ﻋﺒﺎﺭﺓ‬
‫‪ .Onerror‬ﻻ ﺘﻨﺼﺢ ﻤﻴﻜﺭﻭﺴﻭﻓﺕ ﺒﺎﺴﺘﺨﺩﺍﻡ ‪ Onerror‬ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻷﻨﻪ ﻴﺤﻭﻱ ﻋﺩﺩ‬
‫ﻤﺤﺩﻭﺩ ﻤﻥ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ ﺍﻷﺨﻁﺎﺀ ﺃﻤﺎ ﻓﻲ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﺠﺩﻴﺩﺓ ﻓﻲ ﺍﻟﺩﻭﺕ ﻨﺕ ﻓﻴﻤﻜﻥ ﻤﻌﺭﻓﺔ‬
‫ﻤﻌﻠﻭﻤﺎﺕ ﻜﺜﻴﺭﺓ ﻤﺜل ﺭﻗﻡ ﺍﻟﺴﻁﺭ ﺍﻟﺫﻱ ﺤﺩﺙ ﺒﻪ ﺍﻟﺨﻁﺄ ﻭ ﺍﺴﻡ ﺍﻟﺩﺍﻟﺔ ﺍﻟﺘﻲ ﺤﺼل ﺒﻬﺎ ﺍﻟﺨﻁﺄ ﻭ‬
‫ﺍﺴﻡ ﺨﺎﺩﻡ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻫﻭ ﻤﺎ ﻟﻡ ﻴﻜﻥ ﻤﺘﻭﻓﺭﺍ ﻓﻲ ﺍﻟﺴﺎﺒﻕ‪.‬‬
‫‪138‬‬
‫ﺍﻟﻤﻌﺎﻟﺠﺔ ﺍﻟﻬﻴﻜﻠﻴﺔ ﻟﻼﺴﺘﺜﻨﺎﺀﺍﺕ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‬

‫ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﺸﻔﺭﺍﺕ ﺘﻜﺘﺏ ﻟﺘﺤﺩﻴﺩ ﺍﻷﺨﻁﺎﺀ ﻭ ﺍﻻﺴﺘﺠﺎﺒﺔ ﻟﻬﺎ ﺃﺜﻨﺎﺀ ﻋﻤل ﺍﻟﺒﺭﻨﺎﻤﺞ ﺤﺴﺏ‬
‫ﺍﻟﺴﻴﺎﻕ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫‪Try‬‬
‫‪Catch‬‬
‫‪Finally‬‬
‫‪End Try‬‬
‫ﻴﻤﻜﻥ ﺸﺭﺡ ﺴﻴﺎﻕ ﻤﻌﺎﻟﺠﺔ ﺍﻻﺴﺘﺜﻨﺎﺀﺍﺕ ﻤﻥ ﺨﻼل ﺍﻟﻨﻘﺎﻁ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫‪ -١‬ﺘﻜﺘﺏ ﻤﺎ ﺘﺭﻴﺩ ﺃﻥ ﺘﻨﻔﺫﻩ ﻤﻥ ﻜﻭﺩ ﻓﻲ ﻋﺒﺎﺭﺓ ‪.Try‬‬
‫‪ -٢‬ﻋﻨﺩ ﺤﺩﻭﺙ ﺨﻁﺄ ﻴﻘﻭﻡ ﺴﻴﺎﻕ ‪ Catch‬ﺒﻤﻌﺎﻟﺠﺔ ﺍﻟﺨﻁﺄ‪ .‬ﺃﻤﺎ ﻋﻨﺩ ﻋﺩﻡ ﺤﺩﻭﺙ ﺨﻁﺄ ﻓﻼ ﻴﻨﻔﺫ‬
‫ﻤﺤﺘﻭﻯ ﻋﺒﺎﺭﺓ ‪.Catch‬‬
‫‪ -٣‬ﻋﺒﺎﺭﺓ ‪ Finally‬ﻴﺘﻡ ﺘﻨﻔﻴﺫﻫﺎ ﻓﻲ ﻜل ﺍﻷﺤﻭﺍل ﻭﻫﻲ ﻋﺒﺎﺭﺓ ﺍﺨﺘﻴﺎﺭﻴﻪ ﺘﺴﺘﻁﻴﻊ ﻋﺩﻡ ﺍﺴﺘﺨﺩﺍﻤﻬﺎ‬
‫ﺇﺫﺍ ﻟﻡ ﺘﺤﺘﺞ ﻟﻬﺎ‪.‬‬
‫ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﺍﺴﺘﺨﺩﺍﻡ ﻫﻴﻜﻠﻴﺔ ﺍﻻﺴﺘﺜﻨﺎﺀ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‪.‬‬

‫"=‪con.ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source‬‬
‫_ &‬
‫"‪"C:\TelDir.mdb;Persist Security Info=False‬‬
‫‪Try‬‬
‫‪Catch Exp As OleDb.OleDbException‬‬
‫‪Label1.Text = Exp.Message‬‬
‫‪Finally‬‬
‫)(‪con.Close‬‬
‫‪End Try‬‬
‫ﻴﻤﻜﻥ ﺘﻠﺨﻴﺹ ﺍﻟﻤﺜﺎل ﺒﺎﻟﺨﻁﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ -١‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻷﻭل ﻗﻤﻨﺎ ﺒﺘﻌﺭﻴﻑ ﺍﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪ -٢‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻨﻲ ﻗﻤﻨﺎ ﺒﺘﻌﺭﻴﻑ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل‪.‬‬
‫‪ -٣‬ﺒﺩﺃ ﺴﻴﺎﻕ ﻤﻌﺎﻟﺠﺔ ﺍﻻﺴﺘﺜﻨﺎﺀﺍﺕ‪.‬‬
‫‪139‬‬
‫‪ -٤‬ﻓﺘﺢ ﺍﻻﺘﺼﺎل ﻤﻥ ﺨﻼل ﻁﺭﻴﻘﺔ ‪.Open‬‬

‫‪ -٥‬ﺇﻥ ﺤﺼل ﺃﻱ ﺨﻁﺄ ﻓﻲ ﻓﺘﺢ ﺍﻻﺘﺼﺎل ﺴﻭﻑ ﻴﻨﺘﻘل ﺍﻟﺴﻴﺎﻕ ﺇﻟﻰ ﻋﺒﺎﺭﺓ ‪.Catch‬‬
‫‪ -٦‬ﻓﻲ ﻋﺒﺎﺭﺓ ‪ Catch‬ﻗﻤﻨﺎ ﺒﺘﻌﺭﻴﻑ ﻤﺘﻐﻴﺭ ﻤﻥ ﻨﻭﻉ ﺍﺴﺘﺜﻨﺎﺀ ﺨﺎﺹ ﺒـ ‪ Oledb‬ﺜﻡ ﻋﺭﻀﻨﺎ‬
‫ﺍﻟﺭﺴﺎﻟﺔ ﺍﻟﺘﻲ ﺘﻭﻀﺢ ﺍﻻﺴﺘﺜﻨﺎﺀ ﻋﻠﻰ ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ‪.‬‬
‫‪ -٧‬ﻓﻲ ﻜل ﺍﻷﺤﻭﺍل ﺴﻭﺍﺀ ﺤﺼل ﺍﺴﺘﺜﻨﺎﺀ ﺃﻡ ﻟﻡ ﻴﺤﺼل ﺴﻴﺘﻡ ﺇﻏﻼﻕ ﺍﻻﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫ﻁﺒﻕ ﻤﺎ ﺴﺒﻕ ﻤﻥ ﺨﻼل ﺍﻟﺘﺩﺭﻴﺏ ﺍﻟﺘﺎﻟﻲ ‪:‬‬

‫• ﻗﻡ ﺒﺘﻐﻴﻴﺭ ﺍﺴﻡ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫• ﺤﺎﻭل ﺍﻻﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل ﺍﻟﺴﺎﺒﻘﺔ‪.‬‬
‫• ﻴﺠﺏ ﺃﻥ ﻴﻜﻭﻥ ﻫﻨﺎﻙ ﺨﻁﺄ ﻗﻡ ﺒﻤﻌﺎﻟﺠﺘﻪ ﻤﻅﻬﺭﺍ ﺭﺴﺎﻟﺔ ﻋﻠﻰ ﻋﻨﻭﺍﻥ‪.‬‬
‫ﺃﻭﻋﻴﺔ ﺍﻻﺘﺼﺎل ‪:‬‬

‫ﻓﻲ ﻜل ﻤﺭﺓ ﻴﺘﻡ ﻓﻴﻬﺎ ﺍﻻﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻴﺘﻡ ﺍﺴﺘﻬﻼﻙ ﺤﺠﻡ ﻜﺒﻴﺭ ﻤﻥ ﻤﻭﺍﺭﺩ ﺍﻷﺠﻬﺯﺓ‬
‫ﺍﻟﺨﺎﺩﻤﺔ ﻟﺫﺍ ﺘﻘﺘﻀﻲ ﺍﻟﺤﻜﻤﺔ ﺇﺒﻘﺎﺀ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻻﺘﺼﺎﻻﺕ ﻤﺠﻬﺯﺓ ﻓﻲ ﺃﻭﻋﻴﺔ ﺍﺘﺼﺎﻻﺕ ﻤﻤﺎ‬
‫ﻴﺴﺎﻋﺩ ﻋﻠﻰ ﺯﻴﺎﺩﺓ ﻜﻔﺎﺀﺓ ﺍﻟﻨﻅﺎﻡ‪.‬‬
‫‪ .I‬ﺘﻌﺭﻴﻔﻬﺎ ‪:‬‬
‫ﻴﻤﻜﻥ ﺘﻌﺭﻴﻑ ﺃﻭﻋﻴﺔ ﺍﻻﺘﺼﺎل ﺒﺄﻨﻬﺎ ﻋﺒﺎﺭﺓ ﻋﻥ ﻋﻤﻠﻴﺔ ﺇﺒﻘﺎﺀ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻻﺘﺼﺎﻻﺕ ﻤﻔﺘﻭﺤﺔ ﻭ‬
‫ﻤﺠﻤﻭﻋﺔ ﻓﻲ ﻤﻜﺎﻥ ﻤﺎ ﻟﻴﺘﻡ ﺒﻌﺩ ﺫﻟﻙ ﺇﻋﺎﺩﺓ ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ‪.‬‬
‫‪ .II‬ﺸﺭﻭﻁ ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ‪:‬‬

‫ﻴﻭﺠﺩ ﻫﻨﺎﻙ ﺸﺭﻁﺎﻥ ﺃﺴﺎﺴﻴﺎﻥ ﻻﺴﺘﺨﺩﺍﻡ ﺃﻭﻋﻴﺔ ﺍﻻﺘﺼﺎل ‪:‬‬
‫‪ -١‬ﺃﻥ ﻻ ﺘﺨﺘﻠﻑ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل ‪ :‬ﻭﻫﻭ ﻤﺎ ﻴﻌﻨﻲ ﺘﻁﺎﺒﻕ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل ﺘﻁﺎﺒﻘﺎ ﺘﺎﻤﺎ ﺤﺘﻰ‬
‫ﺃﺴﻡ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻓﻲ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل ﻻﺒﺩ ﺃﻥ ﻴﺘﻁﺎﺒﻕ ‪.‬‬
‫‪ -٢‬ﺘﻭﻅﻴﻑ ﺨﺎﺼﻴﺔ ﻭﻋﺎﺀ ﺍﻻﺘﺼﺎل ‪ :‬ﻤﻊ ﺍﻟﻌﻠﻡ ﺃﻥ ﺍﻟﻘﻴﻤﺔ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ﻫﻲ ﺃﻥ ﻭﻋﺎﺀ ﺍﻻﺘﺼﺎل‬
‫ﻤﻭﻅﻑ‪.‬‬
‫ﻋﻨﺩ ﺘﺨﻠﻑ ﺃﺤﺩ ﺍﻟﺸﺭﻁﻴﻥ ﺍﻟﺴﺎﺒﻘﻴﻥ ﻻ ﻴﺘﻡ ﺍﺴﺘﺨﺩﺍﻡ ﻨﻔﺱ ﺍﻻﺘﺼﺎل ﺒل ﺘﻘﻭﻡ ﺒﻴﺌﺔ ﺍﻟﺘﺸﻐﻴل ﺒﺈﻨﺸﺎﺀ‬
‫ﺍﺘﺼﺎل ﺠﺩﻴﺩ ﻭﻤﻥ ﺜﻡ ﻴﺘﻡ ﻭﻀﻌﻪ ﻓﻲ ﻭﻋﺎﺀ ﺠﺩﻴﺩ ﺇﻥ ﺘﻡ ﻁﻠﺏ ﺫﻟﻙ‪.‬‬
‫‪140‬‬
‫‪ .III‬ﻤﻤﻴﺯﺍﺘﻬﺎ ‪:‬‬
‫ﻴﻭﺠﺩ ﻤﻴﺯﺘﺎﻥ ﻫﺎﻤﺘﺎﻥ ﺘﺠﻌﻠﻨﺎ ﻨﻔﻜﺭ ﻓﻲ ﺍﺴﺘﺨﺩﺍﻡ ﺃﻭﻋﻴﺔ ﺍﻻﺘﺼﺎل ﻭﻫﻤﺎ ‪:‬‬
‫‪ -١‬ﺃﺩﺍﺀ ﺃﻋﻠﻰ ﻟﻸﻨﻅﻤﺔ ‪ :‬ﺤﻴﺙ ﺃﻥ ﻓﺘﺢ ﺇﺘﺼﺎل ﺠﺩﻴﺩ ﻟﻜل ﻤﺴﺘﺨﺩﻡ ﻴﺸﻜل ﻋﺒﺄ ﻋﻠﻰ ﺨﺎﺩﻡ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﻜﻤﺎ ﺃﻨﻪ ﻴﺄﺨﺫ ﻭﻗﺘﺎ ﻹﺘﻤﺎﻡ ﻓﺘﺢ ﺍﻻﺘﺼﺎل‪.‬‬
‫‪ -٢‬ﺍﻟﻘﺩﺭﺓ ﻋﻠﻰ ﺍﻟﺘﻭﺴﻊ ﺒﻜﻔﺎﺀﺓ‬
‫ﺇﺫﺍ ﻟﻡ ﻴﺘﻡ ﺍﺴﺘﺨﺩﺍﻡ ﺃﻭﻋﻴﺔ ﺍﻻﺘﺼﺎل ﺒﺸﻜل ﺼﺤﻴﺢ ﻗﺩ ﺘﺅﺜﺭ ﻋﻠﻰ ﺍﺩﺍﺀ ﺍﻟﻨﻅﺎﻡ‪ .‬ﻭﺫﻟﻙ ﺃﻥ ﺍﻟﺘﻭﺴﻊ‬
‫ﻓﻲ ﺇﻜﺜﺎﺭ ﺍﻻﺘﺼﺎﻻﺕ ﻓﻲ ﺤﻭﺽ ﺍﻻﺘﺼﺎل ﻴﺴﺘﻬﻠﻙ ﻤﻭﺍﺭﺩ ﺨﺎﺩﻡ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫ﺘﺘﻀﺢ ﺃﻫﻤﻴﺔ ﺍﺴﺘﺨﺩﺍﻡ ﺃﻭﻋﻴﺔ ﺍﻻﺘﺼﺎل ﻓﻲ ﺘﻁﺒﻴﻘﺎﺕ ﺍﻻﻨﺘﺭﻨﺕ ﻭ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﺍﻟﺘﻲ ﻴﻌﻤل ﻋﻠﻴﻬﺎ‬
‫ﻤﺴﺘﺨﺩﻤﻴﻥ ﻜﺜﺭ‪ .‬ﻴﺫﻜﺭ ﺃﻥ ﻋﻤﻠﻴﺔ ﺘﺠﻤﻴﻊ ﺍﻻﺘﺼﺎﻻﺕ ﺘﺘﻡ ﻓﻲ ﺨﺎﺩﻡ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫‪ -١‬ﻋﻨﺩ ﺇﻏﻼﻕ ﺍﻻﺘﺼﺎل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ Close‬ﻴﺘﻡ ﺘﺭﺤﻴل ﺍﻻﺘﺼﺎل ﺇﻟﻰ ﻭﻋﺎﺀ ﺍﻻﺘﺼﺎﻻﺕ‪.‬‬
‫‪ -٢‬ﻋﻨﺩ ﺇﺘﻼﻑ ﺍﻻﺘﺼﺎل ‪ Dispose‬ﻴﺘﻡ ﺇﻟﻐﺎﺀ ﺍﻻﺘﺼﺎل ﻤﻥ ﺍﻟﺫﺍﻜﺭﺓ ﻭﻻ ﻴﺘﻡ ﺇﺭﺠﺎﻋﻪ ﺇﻟﻰ ﻭﻋﺎﺀ ﺍﻻﺘﺼﺎﻻﺕ‪.‬‬
‫‪ -٣‬ﻋﻨﺩ ﺤﺩﻭﺙ ﺃﺤﺩ ﺍﻷﻤﺭﻴﻥ ﺍﻟﺘﺎﻟﻴﻴﻥ ﻴﺘﻡ ﺇﻟﻐﺎﺀ ﻭﻋﺎﺀ ﺍﻻﺘﺼﺎﻻﺕ‪:‬‬
‫ﺤﺫﻑ ﺁﺨﺭ ﺍﺘﺼﺎل ﻤﻥ ﻭﻋﺎﺀ ‪.‬‬ ‫•‬
‫ﻋﻨﺩ ﻤﺭﻭﺭ ﻭﻗﺕ ﻤﻌﻴﻥ‪.‬‬ ‫•‬
‫‪ -٤‬ﺍﻻﺘﺼﺎل ﺍﻟﺤﺎﻟﻲ ﺍﻟﻤﺸﻐﻭل ﻻ ﻴﻤﻜﻥ ﺍﺴﺘﺨﺩﺍﻤﻪ‪.‬‬
‫‪-٥‬ﺍﻟﻘﻴﻤﺔ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ﻫﻲ ﺍﺴﺘﺨﺩﺍﻡ ﻭﻋﺎﺀ ﺍﻻﺘﺼﺎﻻﺕ‪.‬‬
‫‪ -٦‬ﻋﻨﺩ ﺘﺭﻙ ﺍﻻﺘﺼﺎل ﻤﻔﺘﻭﺤﺎ ﻻ ﻴﺘﻡ ﺇﻋﺎﺩﺘﻪ ﺇﻟﻰ ﻭﻋﺎﺀ ﺍﻻﺘﺼﺎﻻﺕ‪.‬‬
‫‪ -٧‬ﻻ ﻴﺘﻡ ﺍﺴﺘﺨﺩﺍﻡ ﻭﻋﺎﺀ ﺍﻻﺘﺼﺎل ﻓﻲ ﺤﺎﻟﺔ ﺍﺨﺘﻼﻑ ﺍﺴﻡ ﺍﻟﻤﺴﺘﻔﻴﺩ ﻓﻲ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل‪.‬‬
‫‪ -٨‬ﺍﻟﻘﻴﻡ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ ﻟﻠﺨﺎﺼﻴﺘﻴﻥ ‪ Min‬ﻭ ‪ Max‬ﻫﻤﺎ ‪ ٠‬ﻭ ‪ ١٠٠‬ﻋﻠﻰ ﺍﻟﺘﻭﺍﻟﻲ‪.‬‬
‫‪ -٩‬ﺇﺫﺍ ﺘﻡ ﺸﻐل ﻜل ﺍﻻﺘﺼﺎﻻﺕ ﻓﻲ ﺍﻟﻭﻋﺎﺀ ﻤﻊ ﻤﺴﺘﺨﺩﻤﻴﻥ ﻭ ﺠﺎﺀ ﻓﻲ ﻨﻔﺱ ﺍﻟﻭﻗﺕ ﻁﻠﺏ ﺍﺘﺼﺎل ﻤﻥ ﻗﺒل ﻤﺴﺘﺨﺩﻡ‬
‫ﻤﺎ ﻓﺈﻨﻪ ﻴﺘﻡ ﺇﺭﺴﺎل ﻁﻠﺏ ﺍﺘﺼﺎل ﻭ ﻴﺘﻡ ﻭﻀﻊ ﻫﺫﺍ ﺍﻟﻁﻠﺏ ﻓﻲ ﺍﻻﻨﺘﻅﺎﺭ ﺤﺘﻰ ﻴﺘﻡ ﺇﻏﻼﻕ ﺍﺘﺼﺎل ﻤﺎ ﻭﻓﻲ ﺤﺎﻟﺔ ﻤﺭﻭﺭ ﺍﻟﻭﻗﺕ‬
‫‪ Timeout‬ﻭﻋﺩﻡ ﺘﻠﺒﻴﺔ ﺍﻟﻁﻠﺏ ﻓﺈﻨﻪ ﻴﺘﻡ ﺍﻟﺭﺠﻭﻉ ﺒﺨﻁﺄ ‪.‬‬
‫ﺍﻟﻌﻭﺍﻤل ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻓﻲ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل ﻭﺘﺨﺹ ﻭﻋﺎﺀ ﺍﻻﺘﺼﺎﻻﺕ‬

‫ﺍﻟﺸﺭﺡ‬ ‫ﺍﻟﻌﺎﻤل‬
‫‪141‬‬
‫ﺍﻟﻭﻗﺕ ﺒﺎﻟﺜﺎﻨﻴﺔ ﻟﻤﺩﺓ ﺒﻘﺎﺀ ﺍﻻﺘﺼﺎل ﻓﻲ ﻭﻋﺎﺀ ﺍﻻﺘﺼﺎﻻﺕ ﻗﺒل ﺘﺩﻤﻴﺭﻩ‪.‬‬ ‫‪Connection Lifetime‬‬
‫ﺍﻟﻌﺩﺩ ﺍﻷﻗﺼﻰ ﻤﻥ ﺍﻻﺘﺼﺎﻻﺕ ﻓﻲ ﻭﻋﺎﺀ ﺍﻻﺘﺼﺎﻻﺕ‪.‬‬ ‫‪Max Pool Size‬‬
‫ﺍﻟﻌﺩﺩ ﺍﻷﻗل ﻤﻥ ﺍﻻﺘﺼﺎﻻﺕ ﻓﻲ ﻭﻋﺎﺀ ﺍﻻﺘﺼﺎل‪.‬‬ ‫‪Min Pool Size‬‬
‫‪142‬‬
‫ﺍﻟﺒﻴﺌﺔ ﺍﻟﻤﺘﺼﻠﺔ ﻓﻲ ‪ADO.NET‬‬
‫ﻤﺭ ﺒﻨﺎ ﻓﻲ ﺒﺎﺏ ﺍﻟﺒﻴﺌﺔ ﺍﻟﻤﺘﺼﻠﺔ ﻭ ﺍﻟﺒﻴﺌﺔ ﺍﻟﻐﻴﺭ ﻤﺘﺼﻠﺔ‪ ،‬ﺃﻨﻪ ﻓﻲ ﺍﻟﺒﻴﺌﺔ ﺍﻟﻤﺘﺼﻠﺔ ﺘﻭﺠﺩ ﻗﻨﺎﺓ ﺍﺘﺼﺎل‬
‫ﻤﻔﺘﻭﺤﺔ ﻤﻊ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺤﺘﻰ ﺘﺘﻡ ﻋﻤﻠﻴﺔ ﺍﻻﻨﺘﻬﺎﺀ ﻤﻥ ﻫﺩﻑ ﺍﻻﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻤﻥ ﺜﻡ ﻴﺘﻡ‬
‫ﺍﻏﻼﻕ ﺍﻻﺘﺼﺎل‪ .‬ﺘﻤﺜل ﻫﺫﻩ ﺍﻟﺒﻴﺌﺔ ﻓﻲ ‪ ADO.NET‬ﺒﻜﺎﺌﻥ ﺍﻷﻤﺭ ﻭ ﻜﺎﺌﻥ ﻗﺎﺭﺉ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻴﻤﻜﻥ‬
‫ﺘﺨﻴل ﻋﻤل ﺍﻟﺒﻴﺌﺔ ﺍﻟﻤﺘﺼﻠﺔ ﻤﻥ ﺨﻼل ﺍﻟﺸﻜل)‪. (١-١٤‬‬
‫ﺷﻜﻞ ‪ : ١-١٤‬ﻧﻤﻮذج اﻟﺒﻴﺌﺔ اﻟﻤﺘﺼﻠﺔ ﻓﻲ ﺑﻴﺌﺔ اﻟﺪوت ﻧﺖ‬

‫اﻟﻌﻤﻞ ﻓﻲ اﻟﺒﻴﺌﺔ اﻟﻤﺘﺼﻠﺔ‬
‫ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫‪Connection‬‬ ‫‪Command‬‬
‫‪DataReader‬‬
‫ﻁﺭﻴﻘﺔ ﻋﻤل ﺍﻟﺒﻴﺌﺔ ﺍﻟﻤﺘﺼﻠﺔ ‪:‬‬

‫‪ -١‬ﻴﺘﻡ ﺇﻨﺸﺎﺀ ﺍﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪ -٢‬ﻴﺘﻡ ﺘﺤﺩﻴﺩ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﻤﺭﺍﺩ ﺇﺠﺭﺍﺀﻫﺎ‪.‬‬
‫‪-٣‬ﻴﺘﻡ ﻗﺭﺍﺀﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻥ ﺍﺤﺘﻴﺞ ﺇﻟﻰ ﺫﻟﻙ‪.‬‬
‫‪ -٤‬ﻴﺘﻡ ﺇﻏﻼﻕ ﺍﻻﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫ﻟﻌﻠﻙ ﺘﻼﺤﻅ ﺃﻨﻨﺎ ﻨﺴﺘﺨﺩﻡ ﺜﻼﺙ ﻜﺎﺌﻨﺎﺕ ‪:‬ﻫﻲ ﻜﺎﺌﻥ ﺍﻻﺘﺼﺎل‪ ،‬ﻜﺎﺌﻥ ﺍﻷﻤﺭ ﻭ ﻜﺎﺌﻥ ﻗﺎﺭﺉ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪143‬‬
‫ﻜﺎﺌﻥ ﺍﻷﻤﺭ ‪: Command‬‬

‫ﺘﻌﺭﻴﻔﻪ ‪:‬‬ ‫‪.I‬‬
‫ﻴﻤﻜﻥ ﺘﻌﺭﻴﻑ ﺍﻟﻜﺎﺌﻥ ‪ Command‬ﻤﻥ ﺨﻼل ﺘﻘﺴﻴﻡ ﻤﺤﺘﻭﺍﻩ ‪:‬‬
‫‪ -١‬ﺇﻤﺎ ﺃﻥ ﻴﺤﻭﻱ ﺠﻤﻠﺔ ﻟﻐﺔ ﺍﺴﺘﻔﺴﺎﺭ ﺒﻨﺎﺌﻴﺔ ‪.-SQL Statement -‬‬
‫‪ -٢‬ﺃﻭ ﻴﺤﻭﻱ ﺍﺴﺘﺩﻋﺎﺀ ﺇﺠﺭﺍﺀ ﻤﺨﺯﻥ ﻓﻲ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪.-Stored Procedure-‬‬
‫ﻭﻤﻥ ﺜﻡ ﺘﺴﺘﻁﻴﻊ ﺘﻨﻔﻴﺫ ﻫﺫﺍ ﺍﻟﻤﺤﺘﻭﻯ ﻤﻥ ﺨﻼل ﺒﻌﺽ ﺍﻟﻭﻅﺎﺌﻑ ﻓﻲ ﻫﺫﺍ ﺍﻟﻜﺎﺌﻥ ﻭ ﺇﺭﺠﺎﻉ ﺍﻟﻨﺘﻴﺠﺔ ﺇﻟﻰ‬
‫ﻜﺎﺌﻥ ﻗﺎﺭﺉ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪.DataReader‬‬
‫ﻁﺭﻴﻘﺔ ﺍﻟﻭﺼﻭل ﺇﻟﻴﻪ ‪:‬‬ ‫‪.II‬‬
‫ﻴﻤﻜﻥ ﺍﻟﻭﺼﻭل ﻟﻜﺎﺌﻥ ﺍﻷﻤﺭ ﻤﻥ ﺨﻼل ﻓﻀﺎﺀ ﺍﻻﺴﻡ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫‪System.Data.OleDb.OleDbCommand‬‬
‫‪System.Data.SqlClient.SqlCommand‬‬
‫‪ .III‬ﺨﺼﺎﺌﺼﻪ ‪:‬‬
‫ﺘﻭﺠﺩ ﻋﺩﺓ ﺨﺼﺎﺌﺹ ﻟﻜﺎﺌﻥ ﺍﻷﻤﺭ ﺘﻤﻜﻨﻨﺎ ﻤﻥ ﺍﻟﺘﻌﺎﻤل ﻤﻌﻪ ﻭﻫﻲ ‪:‬‬
‫ﻴﻤﺜل ﺍﺴﻡ ﻜﺎﺌﻥ ﺍﻷﻤﺭ ﻭ ﺍﻟﺫﻱ ﺴﻭﻑ ﺘﺘﻌﺎﻤل ﻤﻌﻪ‬ ‫‪Name‬‬

‫ﻓﻲ ﺍﻟﻜﻭﺩ‬
‫ﻜﺎﺌﻥ ﺍﻻﺘﺼﺎل ﺍﻟﻤﺴﺘﺨﺩﻡ ﺍﺴﻡ ﺍﻻﺘﺼﺎل ﺍﻟﺫﻱ ﺴﻭﻑ ﻴﻘﻭﻡ ﺒﺎﺴﺘﺨﺩﺍﻤﻪ ﻜﺎﺌﻥ‬ ‫‪Connection‬‬
‫ﺍﻷﻤﺭ‬
‫ﺘﻨﻔﻴﺫ ﻟﻐﺔ ﺍﺴﺘﻔﺴﺎﺭ ﺒﻨﺎﺌﻴﺔ‬ ‫‪Text‬‬ ‫‪CommandType‬‬
‫ﺘﻨﻔﻴﺫ ﺇﺠﺭﺍﺀ ﻤﻭﺠﻭﺩ ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫‪StoredProcedur‬‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺠﺩﻭل ﻭﺍﺤﺩ‬ ‫‪TableDirect‬‬
‫‪144‬‬
‫‪ -١‬ﻋﺒﺎﺭﺓ ﻟﻐﺔ ﺍﻻﺴﺘﻔﺴﺎﺭ ﺍﻟﺒﻨﺎﺌﻴﺔ ﺍﻟﺘﻲ ﺴﻭﻑ‬ ‫ﺍﻟﺨﺎﺼﻴﺔ‬ ‫ﻋﻠﻰ‬ ‫ﺍﻋﺘﻤﺎﺩﺍ‬ ‫‪CommandText‬‬
‫ﻴﺘﻡ ﺘﻨﻔﻴﺫﻫﺎ ﺴﻭﺍﺀ ﻻﺴﺘﺭﺠﺎﻉ ﺃﻭ ﺘﺤﺩﻴﺙ‬ ‫ﺍﻟﺴﺎﺒﻘﺔ‪CommandType‬‬
‫ﺴﻭﻑ ﻴﻜﻭﻥ ﻟﺩﻴﻨﺎ ﻭﺍﺤﺩ ﻤﻥ‬
‫ﺒﻴﺎﻨﺎﺕ‬
‫ﺜﻼﺙ ﻤﺩﺨﻼﺕ‬
‫‪ -٢‬ﺍﺴﻡ ﺍﻹﺠﺭﺍﺀ ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ﻭ ﺍﻟﺫﻱ ﻨﺭﻴﺩ ﺘﻨﻔﻴﺫﻩ‪.‬‬
‫‪ -٣‬ﺍﺴﻡ ﺍﻟﺠﺩﻭل ﺍﻟﺫﻱ ﻨﺭﻴﺩ ﺍﻟﺘﻌﺎﻤل ﻤﻌﻪ‬
‫ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﺩﺨﻠﺔ ﻓﻲ ﺨﺎﺼﻴﺔ ‪ Command Text‬ﺘﻌﺘﻤﺩ ﻋﻠﻰ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺘﻲ ﺘﻡ ﺍﺨﺘﻴﺎﺭﻫﺎ ﻓﻲ‬
‫ﺍﻟﺨﺎﺼﻴﺔ ‪.CommandType‬‬
‫‪ .IV‬ﻁﺭﻕ ﻜﺎﺌﻥ ﺍﻷﻤﺭ ‪:‬‬
‫ﺴﻭﻑ ﻨﺘﻁﺭﻕ ﻷﻫﻡ ﺜﻼﺜﺔ ﻁﺭﻕ ﻓﻲ ﻜﺎﺌﻥ ﺍﻷﻤﺭ ﻭﻫﻲ ‪:‬‬
‫ﺍﻟﻬﺩﻑ ﻤﻨﻬﺎ‬ ‫ﺍﻟﻁﺭﻴﻘﺔ‬

‫ﺘﻨﻔﻴﺫ ﺍﺴﺘﻌﻼﻡ ﻤﻤﺎ ﻴﺅﺩﻱ ﺇﻟﻰ ﺇﺭﺠﺎﻉ ﺃﻜﺜﺭ ﻤﻥ ﺼﻑ ﻤﻥ ﻗﺎﻋﺩﺓ‬ ‫‪ExecuteReader‬‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻫﻭ ﻤﺎ ﻴﺘﻁﻠﺏ ﺍﺴﺘﺭﺠﺎﻉ ﻫﺫﻩ ﺍﻟﻨﺘﻴﺠﺔ ﺒﻭﺍﺴﻁﺔ ﻜﺎﺌﻥ ﻗﺎﺭﺉ‬
‫ﺘﻨﻔﻴﺫ ﺃﻤﺭ ﻴﻘﻭﻡ ﺒﺘﺤﺩﻴﺙ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺃﻭ ﺘﻜﻭﻴﻥ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ‬ ‫‪ExecuteNonQuery‬‬
‫ﺍﻟﻨﺘﻴﺠﺔ ﺍﻟﺘﻲ ﺘﺭﺠﻊ ﻫﻲ ﻋﺩﺩ ﺍﻟﺼﻔﻭﻑ ﺍﻟﻤﺘﺄﺜﺭﺓ ﺒﺎﻷﻤﺭ‪.‬‬
‫ﺘﻨﻔﻴﺫ ﺃﻤﺭ ﻴﺴﺘﺭﺠﻊ ﻗﻴﻤﺔ ﻭﺍﺤﺩﺓ ﻓﻘﻁ ﻤﻥ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬ ‫‪ExecuteScalar‬‬
‫• ﺘﻨﻔﻴﺫ ﺍﻷﻤﺭ ﺍﻟﺫﻱ ﻴﺭﺠﻊ ﻗﻴﻤﺔ ﻭﺍﺤﺩﺓ‬

‫ﻴﺠﺩﺭ ﺍﻟﻘﻭل ﻫﻨﺎ ﺒﺄﻥ ﻫﺫﻩ ﻤﻥ ﺃﻭﺠﻪ ﺘﻔﻭﻕ ‪ ADO.NET‬ﻋﻠﻰ ‪ ADO‬ﺤﻴﺙ ﺨﺼﺼﺕ ﺩﺍﻟﺔ‬
‫ﻟﺘﻨﻔﻴﺫ ﺍﻷﻭﺍﻤﺭ ﺍﻟﺘﻲ ﺘﺭﺠﻊ ﻗﻴﻤﺔ ﻭﺍﺤﺩﺓ‪.‬‬
‫ﻤﻥ ﺃﻤﺜﻠﺔ ﺍﻷﻭﺍﻤﺭ ﺍﻟﺘﻲ ﻻ ﺘﺭﺠﻊ ﺇﻻ ﻗﻴﻤﺔ ﻭﺍﺤﺩﺓ ‪:‬‬
‫‪ -١‬ﻤﺠﻤﻭﻉ ﻤﺸﺘﺭﻴﺎﺕ ﺍﻟﻴﻭﻡ‪.‬‬
‫‪ -٢‬ﻤﺘﻭﺴﻁ ﺍﻟﻤﺸﺘﺭﻴﺎﺕ ﻫﺫﺍ ﺍﻟﺸﻬﺭ‪.‬‬
‫‪145‬‬
‫‪ -٣‬ﻋﺩﺩ ﺍﻟﻤﻨﺘﺠﺎﺕ ﺍﻟﺘﻲ ﺘﻭﺠﺩ ﺩﺍﺨل ﺍﻟﻤﺴﺘﻭﺩﻉ‪.‬‬
‫ﻓﻴﻤﺎ ﻟﻭ ﺃﻋﺎﺩﺕ ﺠﻤﻠﺔ ‪ SQL‬ﺃﻜﺜﺭ ﻤﻥ ﻗﻴﻤﺔ ﻓﺴﻭﻑ ﻴﺘﻡ ﺇﻫﻤﺎل ﻜل ﺍﻟﻘﻴﻡ ﻤﺎﻋﺩﺍ ﺍﻟﻘﻴﻤﺔ ﺍﻷﻭﻟﻰ‬
‫ﻤﻥ ﺍﻟﺼﻑ ﺍﻷﻭل ﻭ ﺍﻟﻌﺎﻤﻭﺩ ﺍﻷﻭل ﻭﻫﻭ ﻤﺎ ﻴﻅﻬﺭ ﺃﻥ ‪ ADO.NET‬ﺃﻗﻭﻯ ﻤﻥ ‪ ADO‬ﺍﻟﺘﻲ‬
‫ﺘﻌﻴﺩ ﻜل ﺍﻟﻘﻴﻡ‪.‬‬
‫ﺍﻨﻅﺭ ﺇﻟﻰ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻻﺴﺘﺨﺩﺍﻡ ﻜﺎﺌﻥ ﺍﻷﻤﺭ ﻻﺴﺘﺭﺠﺎﻉ ﻗﻴﻤﺔ ﻭﺍﺤﺩﺓ ﻤﻥ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪:‬‬

‫"‪Dim sql As String = "select count(*) from person‬‬
‫_ & ";‪con.ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0‬‬
‫"‪"Data Source=C:\TelDir.mdb;Persist Security Info=False‬‬
‫‪Try‬‬
‫)‪Dim cmd As New OleDb.OleDbCommand(sql, con‬‬
‫‪Label1.Text = cmd.ExecuteScalar().ToString‬‬
‫‪Catch e1 As OleDb.OleDbException‬‬
‫‪Label1.Text = e1.Message‬‬
‫‪End Try‬‬
‫‪ -١‬ﻋﺭﻓﻨﺎ ﺍﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻷﻭل‪.‬‬
‫‪ -٢‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻨﻲ ﻋﺭﻓﻨﺎ ﺠﻤﻠﺔ ﺍﻻﺴﺘﻌﻼﻡ‪.‬‬
‫‪ -٣‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻟﺙ ﻋﺭﻓﻨﺎ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل‪.‬‬
‫‪ -٤‬ﻤﺤﺎﻭﻟﺔ ﻓﺘﺢ ﺍﻻﺘﺼﺎل ﺜﻡ ﺇﻨﺸﺎﺀ ﻜﺎﺌﻥ ﺍﻷﻤﺭ ﻤﻊ ﺇﻋﻁﺎﺌﻪ ﺠﻤﻠﺔ ﺍﻻﺴﺘﻌﻼﻡ ﻭ ﺍﻻﺘﺼﺎل ﺍﻟﺫﻱ‬
‫ﺴﻴﻘﻭﻡ ﺒﺎﺴﺘﺨﺩﺍﻤﻪ‪.‬‬
‫‪ -٥‬ﻗﻤﻨﺎ ﺒﺘﻨﻔﻴﺫ ﺍﻟﻁﺭﻴﻘﺔ ‪ ExecuteScalar‬ﻟﺘﻨﻔﻴﺫ ﺍﻷﻤﺭ ﻭ ﺍﻟﺘﻲ ﺴﻭﻑ ﺘﻌﻴﺩ ﻟﻨﺎ ﻨﺘﻴﺠﺔ ﺍﻟﻌﻤﻠﻴﺔ‪.‬‬
‫‪ -٦‬ﻗﻤﻨﺎ ﺒﻌﺭﺽ ﺍﻟﻨﺘﻴﺠﺔ ﻋﻠﻰ ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ ﻜﻤﺎ ﻓﻲ ﺍﻟﺸﻜل)‪.(٢-١٤‬‬
‫‪ -٧‬ﻓﻲ ﺤﺎﻟﺔ ﺤﺼﻭل ﺨﻁﺄ ﺴﻴﺘﻡ ﺇﻅﻬﺎﺭﻩ ﻓﻲ ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ‪.‬‬
‫ﺷﻜﻞ ‪ : ٢-١٤‬اﺳﺘﺮﺟﺎع ﻗﻴﻤﺔ واﺣﺪة ﻣﻦ ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت‪.‬‬
‫‪146‬‬
‫ﺍﻨﺴﺦ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻤﻊ ﺍﻟﻘﺭﺹ ﺍﻟﻤﺭﻓﻕ ﻭﻀﻌﻬﺎ ﻓﻲ \‪ c:‬ﻤﺒﺎﺸﺭﺓ ﻜﻤﺎ ﺘﺭﻯ ﺫﻟﻙ‬
‫ﻭﺍﻀﺤﺎ ﻤﻥ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل‪ ،‬ﺜﻡ ﻁﺒﻕ ﺍﻟﻤﺜﺎل‪ ،‬ﻀﻊ ﺍﻟﻜﻭﺩ ﺍﻟﺴﺎﺒﻕ ﺩﺍﺨل ﺤﺩﺙ ﺍﻟﻨﻘﺭ ﻓﻲ ﺯﺭ ﺃﻤﺭ‬
‫ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل )‪(٢-١٤‬‬
‫• ﺘﻨﻔﻴﺫ ﺍﻷﻤﺭ ﺍﻟﺫﻱ ﻴﻤﻜﻥ ﺃﻥ ﻴﺭﺠﻊ ﻋﺩﺓ ﺼﻔﻭﻑ‬
‫ﻴﻘﻭﻡ ﻗﺎﺭﺉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﻘﺭﺍﺀﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻟﻰ ﺍﻷﻤﺎﻡ ﻭﻫﻭ ﻜﻤﺎ ﺘﻼﺤﻅ ﻤﻥ ﺍﺴﻤﻪ ﻤﺨﺼﺹ ﻟﻘﺭﺍﺀﺓ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬ﻋﻨﺩ ﺘﻨﻔﻴﺫ ﻜﺎﺌﻥ ﺍﻷﻤﺭ ﺍﻟﺫﻱ ﻴﺭﺠﻊ ﻋﺩﺓ ﺼﻔﻭﻑ ﻴﻤﻜﻨﻙ ﺍﺴﺘﺨﺩﺍﻡ ﻗﺎﺭﺉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﻠﻤﺭﻭﺭ‬
‫ﻋﻠﻰ ﻫﺫﻩ ﺍﻟﺼﻔﻭﻑ‪.‬ﻻﺴﺘﺭﺠﺎﻉ ﻋﺩﺓ ﺼﻔﻭﻑ ﺍﺴﺘﺨﺩﻡ ﺍﻟﻭﻅﻴﻔﺔ ‪.ExecuteReader‬‬
‫ﻋﻨﺩ ﻗﺭﺍﺀﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺎﺴﺘﺨﺩﺍﻡ ﻗﺎﺭﺉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﺈﻥ ﺍﻻﺘﺼﺎل ﻴﺒﻘﻰ ﻤﻔﺘﻭﺤﺎ ﺤﺘﻰ ﺘﻘﻭﻡ ﺒﺈﻏﻼﻗﻪ‪ ،‬ﻟﺫﺍ‬
‫ﻴﺠﺏ ﻋﻠﻴﻙ ﺇﻏﻼﻕ ﺍﻻﺘﺼﺎل ﺤﺎﻟﻤﺎ ﺘﻘﻭﻡ ﺒﺎﻻﻨﺘﻬﺎﺀ ﻤﻥ ﻗﺭﺍﺀﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻴﻤﻜﻥ ﺍﻟﻭﺼﻭل ﻟﻜﺎﺌﻥ‬
‫ﻗﺎﺭﺉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﺨﻼل ﻓﻀﺎﺀ ﺍﻻﺴﻡ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫‪System.Data.OleDb.OleDbDataReader‬‬
‫‪System.Data.SqlClient.SqlDataReader‬‬
‫ﺨﺼﺎﺌﺹ ﻭ ﻭﻅﺎﺌﻑ ﻗﺎﺭﺉ ﺍﻟﺒﻴﺎﻨﺎﺕ‬

‫ﻴﻤﻜﻥ ﺃﻥ ﻨﺴﺘﻌﺭﺽ ﺃﺒﺭﺯ ﺨﺼﺎﺌﺹ ﻗﺎﺭﺉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﺨﻼل ﺍﻟﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫ﺍﻟﻬﺩﻑ ﻤﻨﻬﺎ‬ ‫ﺨﺎﺼﻴﺔ‪-‬ﻭﻅﻴﻔﺔ‬
‫ﻗﺭﺍﺀﺓ ﺍﻟﺼﻑ ﺍﻟﺘﺎﻟﻲ‪ ،‬ﺘﺭﺠﻊ ‪ True‬ﺇﺫﺍ ﻭﺠﺩ ﺍﻟﺼﻑ ﺃﻭ ‪ False‬ﺇﺫﺍ ﻟﻡ ﻴﻭﺠﺩ‬ ‫‪Read‬‬
‫ﺘﺭﺠﻊ ﻗﻴﻤﺔ ﺍﻟﻌﺎﻤﻭﺩ ﺇﻤﺎ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﺴﻡ ﻤﺤﺩﺩ ﺃﻭ ﺭﻗﻤﻪ‬ ‫‪Item‬‬
‫ﺘﺴﺘﺨﺩﻡ ﻻﺴﺘﺭﺠﺎﻉ ﻗﻴﻤﺔ ﺍﻟﺼﻑ ﻜﺎﻤﻼ ﻭﻗﺩ ﺘﻜﻭﻥ ﺃﻜﺜﺭ ﻓﻌﺎﻟﻴﺔ ﻤﻥ ﺍﺴﺘﺭﺠﺎﻉ‬ ‫‪GetValues‬‬
‫ﻗﻴﻤﺔ ﺍﻟﻌﺎﻤﻭﺩ ﻟﻭﺤﺩﻩ‬
‫ﻫل ﺘﺤﺘﻭﻱ ﻗﻴﻤﺔ ‪Null‬‬ ‫‪isDBnull‬‬
‫ﺇﻏﻼﻕ ﻗﺎﺭﺉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻫﻭ ﻻ ﻴﻘﻭﻡ ﺒﺈﻏﻼﻕ ﺍﻻﺘﺼﺎل‬ ‫‪close‬‬
‫‪147‬‬
sql ‫ ﻋﺩﺩ ﺍﻟﺴﺠﻼﺕ ﺍﻟﻤﺘﺄﺜﺭﺓ ﺒﺠﻤﻠﺔ‬RecordsAffected
‫ﻜﻴﻑ ﺘﺴﺘﺨﺩﻡ ﻗﺎﺭﺉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﻤﻌﺎﻟﺠﺔ ﺍﻟﺼﻔﻭﻑ‬

‫ﺴﻭﻑ ﻨﺴﺘﻌﺭﺽ ﻤﺜﺎﻻ ﻴﻭﻀﺢ ﻟﻨﺎ ﻜﻴﻔﻴﺔ ﺍﺴﺘﺨﺩﺍﻡ ﻜﺎﺌﻥ ﺍﻷﻤﺭ ﻭ ﻜﺎﺌﻥ ﻗﺎﺭﺉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻻﺴﺘﺭﺠﺎﻉ‬
: ‫ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﺼﻔﻭﻑ ﻤﻥ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
Dim con As New OleDb.OleDbConnection()
Dim rdName As OleDb.OleDbDataReader
Dim sql As String = "select * from person"
con.ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;" & _
"Data Source=C:\TelDir.mdb;Persist Security Info=False"
Try
con.Open()
Dim cmd As New OleDb.OleDbCommand(sql, con)
rdName = cmd.ExecuteReader()
Do While rdName.Read()
ListBox1.Items.Add(rdName.GetString(1))
Loop
rdName.Close()
Catch e1 As OleDb.OleDbException
Label1.Text = e1.Message
End Try
: ‫ﻟﻜﻲ ﺘﺴﺘﺨﺩﻡ ﻗﺎﺭﺉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﻤﻌﺎﻟﺠﺔ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﺼﻔﻭﻑ ﻗﻡ ﺒﺎﻟﺨﻁﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ‬

‫ ﺇﻀﺎﻓﺔ ﻜﺎﺌﻥ ﺍﻷﻤﺭ ﻭ ﺇﻋﻁﺎﺌﻪ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﻤﻨﺎﺴﺒﺔ‬-١
‫ ﺍﻹﻋﻼﻥ ﻋﻥ ﻗﺎﺭﺉ ﺍﻟﺒﻴﺎﻨﺎﺕ‬-٢
‫ ﻓﺘﺢ ﺍﻻﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬-٣
ExecuteReader ‫ ﺍﺴﺘﺩﻋﺎﺀ ﺍﻟﻭﻅﻴﻔﺔ‬-٤
‫ ﻤﻥ‬False ‫ ﻭ ﺍﻟﻤﺭﻭﺭ ﻋﻠﻰ ﺍﻟﺼﻔﻭﻑ ﺤﺘﻰ ﺘﺭﺠﻊ ﻟﻙ ﻗﻴﻤﺔ‬Read ‫ ﺍﺴﺘﺩﻋﺎﺀ ﺍﻟﻭﻅﻴﻔﺔ‬-٥
.Read ‫ﺍﻟﻭﻅﻴﻔﺔ‬
‫ ﺇﻏﻼﻕ ﻗﺎﺭﺉ ﺍﻟﺒﻴﺎﻨﺎﺕ‬-٦
148
‫ﻟﺘﻨﻔﻴﺫ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﺃﻀﻑ ﺍﻷﺩﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫‪cmdExecute‬‬ ‫‪Name‬‬ ‫‪Button1‬‬
‫ﺍﺴﺘﺭﺠﺎﻉ ﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﻭﻅﻔﻴﻥ‬ ‫‪Text‬‬
‫‪Text‬‬
‫‪ListBox1‬‬ ‫‪Name‬‬ ‫ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ‬
‫ﺘﻨﻔﻴﺫ ﺃﻤﺭ ﻴﺴﺘﺭﺠﻊ ﻋﺩﺓ ﺼﻔﻭﻑ‬ ‫‪Text‬‬ ‫‪Form1‬‬
‫‪Yes‬‬ ‫‪RightToLeft‬‬
‫ﻹﻏﻼﻕ ﺍﻻﺘﺼﺎل ﺒﻌﺩ ﺍﺴﺘﺨﺩﺍﻤﻪ ﺁﻟﻴﺎ ﺍﺴﺘﺨﺩﻡ ﺍﻟﻌﺎﻤل ﺍﻟﺫﻱ ﻴﺅﺩﻱ ﺫﻟﻙ ﻜﻤﺎ ﻓﻲ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ‬
‫)‪rdName = cmd.ExecuteReader(CommandBehavior.CloseConnection‬‬
‫• ﺘﻨﻔﻴﺫ ﺍﻷﻤﺭ ﺍﻟﺫﻱ ﻻ ﻴﺭﺠﻊ ﺃﻱ ﻗﻴﻤﺔ‬

‫ﻴﻤﻜﻥ ﺘﻠﺨﻴﺹ ﺍﻟﺤﺎﻻﺕ ﺍﻟﺘﻲ ﻴﺘﻡ ﻓﻴﻬﺎ ﺘﻨﻔﻴﺫ ﺍﻷﻤﺭ ﺍﻟﺫﻱ ﻻ ﻴﺭﺠﻊ ﻗﻴﻤﺔ ﺒﻤﺎ ﻴﻠﻲ ‪:‬‬
‫‪149‬‬
‫‪ -١‬ﺇﻨﺸﺎﺀ ﻭ ﺇﺩﺍﺭﺓ ﻫﻴﺎﻜل ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‬

‫‪ -٢‬ﺇﻋﻁﺎﺀ ﺃﻭ ﺤﻅﺭ ﺼﻼﺤﻴﺔ ﻟﻤﺴﺘﺨﺩﻡ ﻤﺎ‪.‬‬
‫‪ -٣‬ﺇﻀﺎﻓﺔ ﻭ ﺘﻌﺩﻴل ﻭ ﺤﺫﻑ ﺒﻴﺎﻨﺎﺕ ﻤﻥ ﺠﺩﺍﻭل ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ﺇﻨﺸﺎﺀ ﻭ ﺇﺩﺍﺭﺓ ﻫﻴﺎﻜل ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪DDL‬‬

‫• ﻫﻲ ﺍﻟﻠﻐﺔ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻓﻲ ﺇﻨﺸﺎﺀ ﻭ ﺇﺩﺍﺭﺓ ﻫﻴﺎﻜل ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫• ﻴﻤﻜﻥ ﺍﻟﺘﻤﺜﻴل ﻟﻬﻴﺎﻜل ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺎﻷﻤﺜﻠﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ -١‬ﺍﻟﺠﺩﺍﻭل‬
‫‪ View -٢‬ﺍﻟﻤﺴﺘﻌﺭﻀﺎﺕ‬
‫‪ -٣‬ﺍﻟﻤﺤﻔﺯﺍﺕ ‪Trigger‬‬
‫ﻤﻥ ﺠﻤل ﺘﻌﺭﻴﻑ ﻫﻴﺎﻜل ﺍﻟﺒﻴﺎﻨﺎﺕ ‪:‬‬

‫ﺍﻟﻬﺩﻑ ﻤﻨﻬﺎ‬ ‫ﺍﻟﺠﻤﻠﺔ‬
‫ﺘﺴﺘﺨﺩﻡ ﻹﻨﺸﺎﺀ ﻜﺎﺌﻥ ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﺜل ﺍﻟﺠﺩﻭل‬ ‫‪Create‬‬
‫ﺘﺴﺘﺨﺩﻡ ﻟﺘﻐﻴﻴﺭ ﺼﻔﺎﺕ ﻜﺎﺌﻥ ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫‪ALTER‬‬
‫ﺘﺴﺘﺨﺩﻡ ﻜﺎﺌﻥ ﻤﻥ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫‪DROP‬‬
‫ﻟﻐﺔ ﺍﻟﺘﺤﻜﻡ ﺒﺎﻟﺒﻴﺎﻨﺎﺕ ‪DCL‬‬

‫ﻫﻲ ﺍﻟﻠﻐﺔ ﺍﻟﺘﻲ ﺘﻤﻜﻨﻙ ﻤﻥ ﺇﻋﻁﺎﺀ ﺃﻭ ﺤﻅﺭ ﺼﻼﺤﻴﺔ ﻟﻤﺴﺘﺨﺩﻡ ﻤﺎ‪.‬‬
‫ﻤﻥ ﺠﻤل ﻟﻐﺔ ﺍﻟﺘﺤﻜﻡ ﺒﺎﻟﺒﻴﺎﻨﺎﺕ ‪:‬‬
‫ﺘﺴﺘﺨﺩﻡ ﻟﻤﻨﺢ ﺼﻼﺤﻴﺔ ﻟﻤﺴﺘﺨﺩﻡ ﻋﻠﻰ ﻜﺎﺌﻥ ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫‪Grant‬‬
‫ﺤﻅﺭ ﺍﻟﺼﻼﺤﻴﺔ ﻟﻤﺴﺘﺨﺩﻡ ﻤﺎ‬ ‫‪DENY‬‬
‫ﻜﻴﻑ ﺘﻨﻔﺫ ﺠﻤﻠﺘﻲ ‪ DDL‬ﻭ ‪DCL‬‬
‫‪150‬‬
‫ﻴﺘﻡ ﺘﻨﻔﻴﺫ ﻟﻐﺘﻲ ﺍﻟﺘﺤﻜﻡ ﺒﺎﻟﺒﻴﺎﻨﺎﺕ ﻭ ﺘﻌﺭﻴﻑ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻭﻅﻴﻔﺔ ‪ ExecuteNonQuery‬ﻭ‬
‫ﺍﻟﺘﻲ ﺘﻌﺘﺒﺭ ﺍﺤﺩ ﺍﻟﻭﻅﺎﺌﻑ ﺍﻟﺘﺎﺒﻌﺔ ﻟﻜﺎﺌﻥ ﺍﻷﻤﺭ‪ .‬ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﻭﻅﻴﻔﺔ ﺒﺈﺭﺠﺎﻉ ﻋﺩﺩ ﺍﻟﺼﻔﻭﻑ ﺍﻟﻤﺘﺄﺜﺭﺓ‬
‫ﺒﺎﻟﻌﻤﻠﻴﺔ‪.‬‬
‫ﺨﻁﻭﺍﺕ ﺘﻨﻔﻴﺫ ‪ DDL‬ﻭ ‪DCL‬‬

‫ﻟﻜﻲ ﺘﺴﺘﻭﻋﺏ ﻁﺭﻴﻘﺔ ﺘﻨﻔﻴﺫ ﺠﻤل ﺇﻨﺸﺎﺀ ﻭ ﺇﺩﺍﺭﺓ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻨﻅﺭ ﺇﻟﻰ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫"))‪Dim sql As String = "create table MyNewTable (t5 varchar(10‬‬
‫‪Try‬‬
‫)‪Dim cmd As New OleDb.OleDbCommand(sql, con‬‬
‫‪Label1.Text = cmd.ExecuteNonQuery().ToString‬‬
‫‪End Try‬‬
‫• ﻤﻥ ﺍﻟﻤﺜﺎل ﻗﻤﻨﺎ ﺒﻤﺎ ﻴﻠﻲ ‪:‬‬

‫‪ -١‬ﺇﻨﺸﺎﺀ ﻜﺎﺌﻨﻲ ﺍﻻﺘﺼﺎل ﻭ ﺍﻷﻤﺭ ﻜﻤﺎ ﺘﻌﻠﻤﺕ ﺴﺎﺒﻘﺎ‬
‫‪ -٢‬ﻓﺘﺢ ﺍﻻﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫‪ -٣‬ﺘﺤﺩﻴﺩ ﺍﻟﺠﻤﻠﺔ ﺍﻟﺘﻲ ﺘﺭﻴﺩ ﺘﻨﻔﻴﺫﻫﺎ‬
‫‪ -٤‬ﺍﺴﺘﺩﻋﺎﺀ ﻭﻅﻴﻔﺔ ‪ExceuteNonQuery‬‬
‫‪ -٥‬ﺇﻏﻼﻕ ﺍﻻﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ﺴﻭﻑ ﺘﻜﻭﻥ ﻨﺘﻴﺠﺔ ﻋﻤﻠﻴﺔ ﺇﻨﺸﺎﺀ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺼﻔﺭ ﺇﺫﺍ ﻨﺠﺤﺕ ﺍﻟﻌﻤﻠﻴﺔ ﻭ ﻏﻴﺭ ﺫﻟﻙ ﺇﺫﺍ ﻟﻡ‬
‫ﺘﻨﺠﺢ‪.‬‬
‫ﺠﻤل ﺘﻌﺩﻴل ﺍﻟﺒﻴﺎﻨﺎﺕ ‪DML‬‬
‫ﺠﻤل ﺘﻌﺩﻴل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻜﻤﺎ ﺘﺩل ﻋﻠﻴﻬﺎ ﺍﻟﺘﺭﺠﻤﺔ ﺍﻟﺤﺭﻓﻴﺔ ﻭﻫﻲ ﺍﻟﺠﻤل ﺍﻟﺘﻲ ﺘﻤﻜﻨﻙ ﻤﻥ ﺍﻀﺎﻓﺔ ﻭ‬
‫ﺘﻌﺩﻴل ﻭ ﺤﺫﻑ ﺒﻴﺎﻨﺎﺕ ﻤﻥ ﺠﺩﺍﻭل ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ﺠﻤل ﻟﻐﺔ ﺘﻌﺩﻴل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻫﻲ ‪:‬‬
‫‪151‬‬
‫ﻭﻫﻲ ﺍﻟﺠﻤﻠﺔ ﺍﻟﺘﻲ ﺘﺴﺘﺨﺩﻡ ﻹﻀﺎﻓﺔ ﺒﻴﺎﻨﺎﺕ ﺇﻟﻰ ﺠﺩﻭل ﻓﻲ ﻗﺎﻋﺩﺓ‬ ‫‪INSERT‬‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ﻭﻫﻲ ﺍﻟﺠﻤﻠﺔ ﺍﻟﺘﻲ ﺘﺴﺘﺨﺩﻡ ﻟﺘﺤﺩﻴﺙ ﺒﻴﺎﻨﺎﺕ ﺴﺒﻕ ﺍﺩﺨﺎﻟﻬﺎ‬ ‫‪UPDATE‬‬
‫ﺤﺫﻑ ﺼﻑ ﺃﻭ ﺃﻜﺜﺭ ﻤﻥ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫‪DELETE‬‬
‫ﻜﻴﻑ ﺘﻨﻔﺫ ‪DML‬‬

‫ﻴﺘﻡ ﺘﻨﻔﻴﺫ ﻟﻐﺔ ﺘﻌﺩﻴل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻭﻅﻴﻔﺔ ‪ ExecuteNonQuery‬ﻭ ﺍﻟﺘﻲ ﺘﻌﺘﺒﺭ ﺍﺤﺩ‬
‫ﺍﻟﻭﻅﺎﺌﻑ ﺍﻟﺘﺎﺒﻌﺔ ﻟﻜﺎﺌﻥ ﺍﻷﻤﺭ‪.‬ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﻭﻅﻴﻔﺔ ﺒﺈﺭﺠﺎﻉ ﻋﺩﺩ ﺼﺤﻴﺢ ﻴﻤﺜل ﻋﺩﺩ ﺍﻟﺼﻔﻭﻑ‬
‫ﺍﻟﻤﺘﺄﺜﺭﺓ ﺒﺎﻟﻌﻤﻠﻴﺔ‪.‬‬
‫ﻟﻜﻲ ﺘﺴﺘﻭﻋﺏ ﻁﺭﻴﻘﺔ ﺘﻨﻔﻴﺫ ﺠﻤل ﻟﻐﺔ ﺘﻌﺩﻴل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻨﻅﺭ ﺇﻟﻰ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫‪ -١‬ﺃﻨﺸﺊ ﻨﻤﻭﺫﺠﺎ ﻭ ﻀﻊ ﻓﻴﻪ ﺍﻟﻜﺎﺌﻨﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻭ ﻏﻴﺭ ﺨﺼﺎﺌﺼﻬﺎ ﻜﻤﺎ ﻴﻠﻲ ‪:‬‬

‫‪cmdExecute‬‬ ‫‪Name‬‬ ‫‪Button1‬‬
‫ﺇﻀﺎﻓﺔ ﺴﺠل ﺍﻟﻤﻭﻅﻑ‬ ‫‪Text‬‬
‫‪Text‬‬
‫ﺍﺴﻡ ﺍﻟﻤﻭﻅﻑ ﺒﺎﻟﻌﺭﺒﻲ‬ ‫‪Text‬‬
‫‪Label٣‬‬ ‫‪Name‬‬ ‫‪Label٣‬‬
‫ﺍﺴﻡ ﺍﻟﻤﻭﻅﻑ ﺒﺎﻹﻨﺠﻠﻴﺯﻱ‬ ‫‪Text‬‬
‫‪Textbox1‬‬ ‫‪Name‬‬ ‫ﻤﺭﺒﻊ ﻨﺹ‬
‫‪Text‬‬
‫‪Textbox1‬‬ ‫‪Name‬‬ ‫‪TextBox2‬‬
‫‪Text‬‬
‫‪Yes‬‬ ‫‪RightToLeft‬‬ ‫‪Form1‬‬
‫‪-2‬ﺍﻜﺘﺏ ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ ﻓﻲ ﺤﺩﺙ ﺍﻟﻨﻘﺭ ﻟﺯﺭ ﺍﻷﻤﺭ‬

‫_ & " ‪Dim sql As String = "insert into person (name,ename) values‬‬
‫")'" & ‪"('" & TextBox1.Text & "','" & TextBox2.Text‬‬
‫_ & "‪con.ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source‬‬
‫‪152‬‬
"=C:\TelDir.mdb;Persist Security Info=False"

Try
con.Open()
Dim cmd As New OleDb.OleDbCommand(sql, con)
Label1.Text = cmd.ExecuteNonQuery().ToString
End Try
: ‫• ﻟﻔﻬﻡ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﺍﺘﺒﻊ ﻤﺎ ﻴﻠﻲ‬

‫ ﺃﻨﺸﺊ ﻜﺎﺌﻨﻲ ﺍﻻﺘﺼﺎل ﻭ ﺍﻷﻤﺭ ﻜﻤﺎ ﺘﻌﻠﻤﺕ ﺴﺎﺒﻘﺎ‬-١
‫ ﺍﻓﺘﺢ ﺍﻻﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬-٢
ExceuteNonQuery ‫ ﻗﻡ ﺒﺎﺴﺘﺩﻋﺎﺀ ﻭﻅﻴﻔﺔ‬-٣
‫ ﺃﻏﻠﻕ ﺍﻻﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬-٤
‫ ﻭﻫﻭ ﻴﻤﺜل ﻋﺩﺩ ﺍﻟﺴﺠﻼﺕ‬١ ‫ ﺍﻨﻅﺭ ﺍﻟﺸﻜل ﺍﻟﻨﻬﺎﺌﻲ ﺒﻌﺩ ﺍﻟﺘﻨﻔﻴﺫ ﺤﻴﺙ ﺭﺠﻊ ﻟﻨﺎ ﻗﻴﻤﺔ‬-٥
‫ﺍﻟﻤﺘﺄﺜﺭﺓ‬
153
‫ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﻭﺍﺤﺩﺓ‬

‫ﻤﺎ ﻫﻲ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﻭﺍﺤﺩﺓ‬
‫ﻴﻤﻜﻥ ﺘﻌﺭﻴﻑ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﻭﺍﺤﺩﺓ ﺒﺄﻨﻬﺎ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﻌﻤﻠﻴﺎﺕ ﺍﻟﺘﻲ ﺇﻤﺎ ﺃﻥ ﺘﻨﻔﺫ ﺒﺎﻟﻜﺎﻤل ﺃﻭ ﻻ ﻴﻨﻔﺫ‬
‫ﻤﻨﻬﺎ ﺸﻲﺀ ﻋﻠﻰ ﺍﻹﻁﻼﻕ‪ .‬ﺇﺫﺍ ﻨﺠﺤﺕ ﻜل ﻫﺫﻩ ﺍﻟﻌﻤﻠﻴﺎﺕ ﻓﺈﻨﻪ ﺴﻭﻑ ﻴﺘﻡ ﺍﻻﻟﺘﺯﺍﻡ –‪-Commit‬‬
‫ﺒﻜل ﺍﻟﻌﻤﻠﻴﺎﺕ ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺃﻤﺎ ﺇﺫﺍ ﻓﺸﻠﺕ ﺃﻱ ﻤﻥ ﺍﻟﻌﻤﻠﻴﺎﺕ ﻓﺈﻨﻪ ﺴﻭﻑ ﻴﺘﻡ ﺍﻟﺘﺭﺍﺠﻊ ﻋﻥ ﻜل‬
‫ﻋﻤﻠﻴﺎﺕ ﺍﻟﺘﺤﺩﻴﺙ ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ – ‪. – RollBack‬‬
‫ﻴﻌﺘﺒﺭ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﻭﺍﺤﺩﺓ ﻤﻬﻡ ﺠﺩﺍ ﺤﺘﻰ ﻻ ﻴﺤﺩﺙ ﺨﻠل ﻓﻲ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﻗﺎﻋﺩﺓ‬
‫ﺃﻤﺜﻠﺔ ﻋﻤﻠﻴﺔ ﻋﻠﻰ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﻭﺍﺤﺩﺓ‬
‫ﺇﻟﻴﻙ ﻫﺫﺍ ﺍﻟﻤﺜﺎل ﻤﻥ ﺍﻟﻭﺍﻗﻊ ‪:‬‬
‫‪ -١‬ﻋﻨﺩ ﺇﻀﺎﻓﺔ ﻓﺎﺘﻭﺭﺓ ﺇﻟﻰ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﺈﻥ ﺍﻟﻔﺎﺘﻭﺭﺓ ﺘﺘﻜﻭﻥ ﻤﻥ ﺠﺯﺃﻴﻥ ﻫﻤﺎ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ‬
‫ﺍﻷﺴﺎﺴﻴﺔ ﻟﻠﻔﺎﺘﻭﺭﺓ ﻤﺜل ﺭﻗﻡ ﺍﻟﻔﺎﺘﻭﺭﺓ ﻭ ﺘﺎﺭﻴﺨﻬﺎ ﻭ ﺍﻟﺠﺯﺀ ﺍﻟﺜﺎﻨﻲ ﻫﻭ ﺘﻔﺎﺼﻴل ﺍﻟﻔﺎﺘﻭﺭﺓ ﻤﺜل ﺍﻷﺼﻨﺎﻑ‬
‫ﻭ ﺍﻟﻜﻤﻴﺎﺕ‪ ،‬ﻓﻲ ﺍﻟﺒﺩﺍﻴﺔ ﻻﺒﺩ ﻤﻥ ﺇﻀﺎﻓﺔ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺍﻷﺴﺎﺴﻴﺔ ﺜﻡ ﺍﺴﺘﺭﺠﺎﻉ ﺍﻟﺭﻗﻡ ﺍﻷﺴﺎﺴﻲ ﻤﻥ ﺠﺩﻭل‬
‫ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺍﻷﺴﺎﺴﻴﺔ ﺜﻡ ﺇﻀﺎﻓﺔ ﺍﻟﺘﻔﺎﺼﻴل ﺍﻟﻭﺍﺤﺩ ﺘﻠﻭ ﺍﻵﺨﺭ‪ .‬ﻋﻨﺩ ﻓﺸل ﺇﻀﺎﻓﺔ ﺍﻟﺘﻔﺎﺼﻴل ﻴﺘﻭﺠﺏ‬
‫ﺍﻟﺘﺭﺍﺠﻊ ﻋﻥ ﺍﻹﻀﺎﻓﺎﺕ ﺍﻟﺴﺎﺒﻘﺔ ﻭ ﺇﻻ ﻨﺘﺞ ﻋﻥ ﺫﻟﻙ ﻓﺎﺘﻭﺭﺓ ﻏﻴﺭ ﻤﻜﺘﻤﻠﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪ -٢‬ﻋﻨﺩ ﺍﻟﺨﺼﻡ ﻤﻥ ﺍﻟﺤﺴﺎﺏ ﺍﻷﻭل ﻭ ﺍﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺤﺴﺎﺏ ﺁﺨﺭ ﻓﻲ ﻨﻔﺱ ﺍﻟﻭﻗﺕ ﻓﺈﻨﻪ ﻋﻨﺩ‬
‫ﻨﺠﺎﺡ ﻋﻤﻠﻴﺔ ﺍﻟﺨﺼﻡ ﻤﻥ ﺍﻟﺤﺴﺎﺏ ﺍﻷﻭل ﻭ ﻓﺸل ﻋﻤﻠﻴﺔ ﺍﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺍﻟﺤﺴﺎﺏ ﺍﻟﺜﺎﻨﻲ ﻓﺈﻥ ﺍﻟﻌﻤﻠﻴﺔ ﻜﻠﻬﺎ‬
‫ﺘﻌﺘﺒﺭ ﻋﻤﻠﻴﺔ ﻓﺎﺸﻠﺔ ﻴﺠﺏ ﺍﻟﺘﺭﺍﺠﻊ ﻋﻨﻬﺎ ﻭ ﺇﻻ ﺃﺼﺒﺢ ﻫﻨﺎﻙ ﺨﻠل ﻓﻲ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫ﺃﻨﻭﺍﻉ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﻭﺍﺤﺩﺓ‬
‫• ﻋﻤﻠﻴﺔ ﻤﺤﻠﻴﺔ ‪ :‬ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﺘﺴﺘﻬﺩﻑ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﻭﺍﺤﺩﺓ ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﻭﺍﺤﺩﺓ ﻻ ﻏﻴﺭ‪ .‬ﻫﺫﺍ‬
‫ﺍﻟﻨﻭﻉ ﺴﻬل ﺍﻟﺘﻁﺒﻴﻕ ﻭﻤﺩﻋﻭﻡ ﻤﻥ ﻗﺒل ﺠﻤﻴﻊ ﻤﺯﻭﺩﻱ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫• ﻋﻤﻠﻴﺔ ﻤﻭﺯﻋﺔ ‪ :‬ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﺘﺴﺘﻬﺩﻑ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﻭﺍﺤﺩﺓ ﺃﻜﺜﺭ ﻤﻥ ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﻭ ﻴﺠﺏ ﺃﻥ‬
‫ﺘﻨﺠﺢ ﻜل ﺍﻟﻌﻤﻠﻴﺎﺕ ﺍﻟﺘﻲ ﺘﻨﺘﻤﻲ ﻟﻠﻌﻤﻠﻴﺔ ﺍﻟﻭﺍﺤﺩﺓ ﺃﻭ ﻴﺘﻡ ﺍﻟﺘﺭﺍﺠﻊ ﻋﻨﻬﺎ ﻜﻠﻬﺎ‪.‬‬
‫‪154‬‬
My
My
‫ رﻳﺎل‬١٠٠ ‫إﺿﺎﻓﺔ‬ Component ‫ رﻳﺎل‬١٠٠ ‫ﺧﺼﻢ‬
Component
‫اﻟﻤﺪﻳﻦ‬
‫ﺣﺴﺎباﻟﻤﺪﻳﻦ‬
‫ﺣﺴﺎب‬ ‫اﻟﺪاﺋﻦ‬
‫ﺣﺴﺎباﻟﺪاﺋﻦ‬
‫ﺣﺴﺎب‬
‫اﻟﻌﻤﻠﻴﺔ اﻟﻮاﺣﺪة‬
ADO.NET ‫ﻜﻴﻑ ﺘﺩﻴﺭ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﻭﺍﺤﺩﺓ ﺒﺎﺴﺘﺨﺩﺍﻡ‬
: ‫ ﺍﺘﺒﻊ ﺍﻟﺨﻁﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ‬،‫ ﻫﺫﻩ ﺍﻟﺨﻁﻭﺍﺕ ﺘﻭﻀﺢ ﻟﻙ ﻜﻴﻔﻴﺔ ﺘﻨﻔﻴﺫ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﻭﺍﺤﺩﺓ‬z
‫ﻭﻫﻲ ﺃﺤﺩ ﺍﻟﻭﻅﺎﺌﻑ ﺍﻟﺘﺎﺒﻌﺔ ﻟﻠﻜﺎﺌﻥ‬ BeginTransaction ‫ ﻗﻡ ﺒﺎﺴﺘﺩﻋﺎﺀ ﺍﻟﻭﻅﻴﻔﺔ‬-١
Connection
‫ ﻭﺍﺠﻌل ﻗﻴﻤﺘﻪ ﺘﺴﺎﻭﻱ ﺍﻟﻭﻅﻴﻔﺔ ﺍﻟﺘﻲ ﻋﺭﻓﺘﻬﺎ‬Oletransaction ‫ ﻋﺭﻑ ﻤﺘﻐﻴﺭﺍ ﻤﻥ ﻨﻭﻉ‬-٢
١ ‫ﻓﻲ ﺍﻟﺨﻁﻭﺓ ﺭﻗﻡ‬
‫ ﺇﻟﻰ ﺍﻟﻤﺘﻐﻴﺭ ﺍﻟﺫﻱ ﻋﺭﻓﺘﻪ ﻓﻲ‬Transaction ‫ ﺍﺸﺭ ﻓﻲ ﻜﺎﺌﻥ ﺍﻷﻤﺭ ﻤﻥ ﺨﻼل ﺨﺎﺼﻴﺔ‬-٣
٢ ‫ﺍﻟﺨﻁﻭﺓ ﺭﻗﻡ‬
‫ ﺃﻤﺎ ﺇﺫﺍ ﻟﻡ ﺘﻨﺠﺢ ﺍﻟﻌﻤﻠﻴﺔ‬Commit ‫ ﺇﺫﺍ ﻨﺠﺤﺕ ﺍﻟﻌﻤﻠﻴﺔ ﻗﻡ ﺒﺎﺴﺘﺩﻋﺎﺀ‬. ‫ ﻨﻔﺫ ﺠﻤﻴﻊ ﺍﻷﻭﺍﻤﺭ‬-٤
Rollback ‫ﻓﻘﻡ ﺒﺎﺴﺘﺩﻋﺎﺀ‬
: ‫ﺍﻨﻅﺭ ﺇﻟﻰ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻻﺴﺘﺨﺩﺍﻡ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﻭﺍﺤﺩﺓ‬

con.ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data
Source=C:\TelDir.mdb;Persist Security Info=False"
con.Open()
Dim cmd As New OleDb.OleDbCommand()
Dim trans As OleDb.OleDbTransaction = con.BeginTransaction
cmd.Connection = con
cmd.Transaction = trans
Dim sql1 As String = "insert into person (name,ename) values ('" &
TextBox1.Text & "','" & TextBox2.Text & "')"
Dim sql2 As String = "insert into Teltype (name,ename) values ('" &
TextBox3.Text & "','" & TextBox4.Text & "')"
Try
cmd.CommandText = sql1
cmd.ExecuteNonQuery()
cmd.CommandText = sql2
cmd.ExecuteNonQuery()
155
‫)(‪trans.Commit‬‬
‫)(‪trans.Rollback‬‬
‫‪End Try‬‬
‫ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﺍﻟﻜﻭﺩ ﺍﻟﻤﻭﺠﻭﺩ ﺒﺨﻁ ﻋﺭﻴﺽ ﻫﻭ ﺍﻟﻜﻭﺩ ﺍﻟﺫﻱ ﻴﻘﻭﻡ ﺒﺈﺩﺍﺭﺓ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﻭﺍﺤﺩﺓ‪ ،‬ﻻﺤﻅ‬
‫ﺃﻨﻨﺎ ﻨﻘﻭﻡ ﺒﻌﻤﻠﻴﺘﻲ ﺇﻀﺎﻓﺔ ﻋﻠﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﺈﺫﺍ ﻨﺠﺤﺕ ﺍﻷﻭﻟﻰ ﺜﻡ ﻓﺸﻠﺕ ﺍﻟﺜﺎﻨﻴﺔ ﻓﺈﻨﻪ ﺴﻭﻑ ﻴﺘﻡ‬
‫ﺍﻟﺘﺭﺍﺠﻊ ﻋﻥ ﻋﻤﻠﻴﺔ ﺍﻹﻀﺎﻓﺔ ﺍﻷﻭﻟﻰ‪ ،‬ﻭﻫﻭ ﻤﺎ ﻴﻀﻤﻥ ﺒﻘﺎﺀ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺩﻗﻴﻘﺔ‪.‬‬
‫ﺩﺭﺠﺎﺕ ﺍﻟﻌﺯل‬
‫ﻤﺎ ﻫﻲ ﺩﺭﺠﺎﺕ ﺍﻟﻌﺯل‬
‫ﻴﻤﻜﻥ ﺘﻌﺭﻴﻑ ﺩﺭﺠﺎﺕ ﺍﻟﻌﺯل ﺒﺄﻨﻬﺎ ﺃﺩﺍﺀ ﺇﻗﻔﺎل ﻋﻤﻠﻴﺔ ﻟﻼﺘﺼﺎل‪ .‬ﺒﺎﻟﻁﺒﻊ ﻴﺘﻭﺠﺏ ﻋﻠﻴﻙ ﺍﺨﺘﻴﺎﺭ‬
‫ﺩﺭﺠﺔ ﺍﻟﻌﺯل ﺍﻟﻤﻨﺎﺴﺒﺔ ﻋﻨﺩ ﺘﻀﺎﺭﺏ ﺃﻜﺜﺭ ﻤﻥ ﻋﻤﻠﻴﺔ ﻋﻠﻰ ﻨﻔﺱ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫ﻤﺜﺎل ﻓﻲ ﺍﻟﺩﻭﺕ ﻨﺕ ﻴﻭﻀﺢ ﻜﻴﻔﻴﺔ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻌﺯل ‪:‬‬
‫‪HRMTran=HRMCon.BeginTransaction(isolationLevel.Serialzable‬‬
‫ﺃﻤﺜﻠﺔ ﻟﻤﺸﺎﻜل ﺍﻟﻌﻤل ﺍﻟﺠﻤﺎﻋﻲ‬

‫ﻴﻤﻜﻥ ﺇﻋﻁﺎﺀ ﺃﺸﻬﺭ ﻤﺜﺎﻟﻴﻥ ﻟﻤﺸﺎﻜل ﺍﻟﻌﻤل ﺍﻟﺠﻤﺎﻋﻲ‬
‫‪ Dirty Read -١‬ﺍﻟﻘﺭﺍﺀﺓ ﺍﻟﻤﻠﻭﺜﺔ ‪ :‬ﻭ ﺘﺤﺼل ﻋﻨﺩﻤﺎ ﺘﻘﻭﻡ ﻋﻤﻠﻴﺔ ﻤﺎ ﺒﻘﺭﺍﺀﺓ ﺒﻴﺎﻨﺎﺕ ﻴﺘﻡ‬
‫ﺘﺤﺩﻴﺜﻬﺎ ﻤﻥ ﻗﺒل ﻋﻤﻠﻴﺔ ﺃﺨﺭﻯ ﻟﻜﻥ ﻟﻡ ﺘﺘﻡ ﺇﻟﺯﺍﻡ –‪ -Commit‬ﺍﻟﺘﺤﺩﻴﺜﺎﺕ ﻋﻠﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫ﺒﺎﻟﻁﺒﻊ ﻷﻥ ﺍﻟﻘﺭﺍﺀﺓ ﺍﻟﺘﻲ ﺘﺘﻡ ﻓﻲ ﻫﺫﺍ ﺍﻟﻭﻗﺕ ﻗﺩ ﻻ ﺘﻌﻁﻲ ﻤﻌﻠﻭﻤﺎﺕ ﺩﻗﻴﻘﺔ ﻋﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪ Phantom Read -٢‬ﺍﻟﻘﺭﺍﺀﺓ ﺍﻟﺨﻴﺎﻟﻴﺔ ‪ :‬ﻭﺘﺤﺩﺙ ﻋﻨﺩﻤﺎ ﺘﻘﻭﻡ ﻋﻤﻠﻴﺔ ﻤﺎ ﺒﻘﺭﺍﺀﺓ ﺒﻴﺎﻨﺎﺕ ﻴﺘﻡ‬
‫ﺤﺫﻓﻬﺎ ﻤﻥ ﻗﺒل ﻋﻤﻠﻴﺔ ﺃﺨﺭﻯ ﻟﻜﻥ ﻟﻡ ﺘﺘﻡ ﻋﻤﻠﻴﺔ ﺇﻟﺯﺍﻡ ﺍﻟﺘﺤﺩﻴﺜﺎﺕ ﻋﻠﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪156‬‬
‫ﺍﺭﺸﺎﺩﺍﺕ ﻻﺨﺘﻴﺎﺭ ﺩﺭﺠﺔ ﺍﻟﻌﺯل‬

‫ﻴﻭﻓﺭ ﻟﻨﺎ ﺍﻟﻜﺎﺌﻥ ‪ OLEDBTransaction‬ﺨﺎﺼﻴﺔ ﺘﺴﻤﻰ ‪ IsolationLevel‬ﻭ ﺘﻘﻭﻡ ﺒﺎﺨﺘﻴﺎﺭ‬
‫ﻗﻴﻤﺔ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻋﻨﺩﻤﺎ ﺘﺒﺩﺃ ﻋﻤﻠﻴﺔ ﻭﺍﺤﺩﺓ ‪BeginTransaction‬‬
‫ﺍﻟﺸﺭﺡ‬ ‫ﺍﻟﻘﻴﻤﺔ‬
‫ﻭﻫﻭ ﺍﻟﻌﺯل ﺍﻟﺫﻱ ﻴﺴﻤﺢ ﺒﻘﺭﺍﺀﺓ ﻜل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻏﻴﺭ‬ ‫‪ReadUncommitted‬‬

‫ﺍﻟﻤﻠﺯﻤﺔ ﻓﻲ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻠﺫﻟﻙ ﺴﻭﻑ ﺘﺤﺼل‬
‫‪ Dirty Read‬ﻭ ‪.Phantom Read‬‬
‫ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﻴﺘﻡ ﻋﺯل ﺠﻤﻴﻊ ﺍﻟﻌﻤﻠﻴﺎﺕ ﻋﻥ ﺒﻌﻀﻬﺎ‬ ‫‪Serializable‬‬
‫ﻓﻼ ﺘﺤﺼل ‪ Dirty Read‬ﻭ ﻻ ‪Phantom Read‬‬
‫ﺴﻭﻑ ﻴﺘﻡ ﻤﻨﻊ ‪ Dirty Read‬ﻭﻫﻭ ﻤﺎ ﻴﻌﻨﻲ ﺃﻥ‬ ‫‪Readcommitted‬‬
‫ﺍﻟﻌﻤﻠﻴﺔ ﻟﻥ ﺘﻘﺭﺃ ﺇﻻ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﺘﻡ ﺇﻟﺯﺍﻡ ﺘﺤﺩﻴﺜﻬﺎ ﻓﻲ‬
‫ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﻜﻥ ﻟﻥ ﻴﺘﻡ ﻤﻨﻊ ‪Phantom Read‬‬
‫ﻭﻫﺫﻩ ﻫﻲ ﺍﻟﻘﻴﻤﺔ ﺍﻻﻓﺘﺭﺍﻀﻴﺔ‬
‫‪157‬‬
‫ﺍﻟﻌﻤل ﻤﻊ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪DATASET‬‬

‫ﻓﻲ ﺍﻟﻔﺼل ﺍﻟﺫﻱ ﺘﻜﻠﻤﻨﺎ ﻓﻴﻪ ﻋﻥ ﺍﻟﺒﻴﺌﺔ ﻏﻴﺭ ﺍﻟﻤﺘﺼﻠﺔ ﻗﻤﻨﺎ ﺒﺘﻌﺭﻴﻔﻬﺎ ﻜﻤﺎ ﻴﻠﻲ ‪ :‬ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ﻴﺘﻡ ﻨﺴﺨﻬﺎ ﻭ ﺘﻌﺩﻴﻠﻬﺎ ﻤﻥ ﻤﺼﺩﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻤﻥ ﺜﻡ ﺇﺭﺠﺎﻉ ﻫﺫﻩ ﺍﻟﺘﻌﺩﻴﻼﺕ ﺇﻟﻰ ﻤﺼﺩﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻟﺫﻟﻙ‬
‫ﺘﻌﺘﺒﺭ ﺍﻟﺒﻴﺌﺔ ﻏﻴﺭ ﺍﻟﻤﺘﺼﻠﺔ ﻫﻲ ﺍﻟﺒﻴﺌﺔ ﺍﻟﻤﺜﺎﻟﻴﺔ ﻋﻨﺩﻤﺎ ﻴﻜﻭﻥ ﺃﺩﺍﺀ ﺍﻟﻨﻅﺎﻡ ﻫﻭ ﺍﻟﻤﺤﻙ‪.‬‬
‫ﺘﺯﻭﺩﻨﺎ ‪ ADO.NET‬ﺒﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﻜﺎﺌﻨﺎﺕ ﻟﻠﻌﻤل ﻓﻲ ﺍﻟﺒﻴﺌﺔ ﻏﻴﺭ ﺍﻟﻤﺘﺼﻠﺔ‪ .‬ﻴﻭﺠﺩ ﻜﺎﺌﻨﺎﻥ‬

‫ﺃﺴﺎﺴﻴﺎﻥ ﻟﻠﻌﻤل ﻓﻲ ﺍﻟﺒﻴﺌﺔ ﻏﻴﺭ ﺍﻟﻤﺘﺼﻠﺔ ﻭ ﻫﻤﺎ ‪:‬‬
‫‪ -١‬ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ : Dataset‬ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻥ ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﺼﻐﻴﺭﺓ ﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﺫﺍﻜﺭﺓ‬
‫ﺘﻤﻜﻨﻙ ﻤﻥ ﺇﻨﺸﺎﺀ ﺠﺩﺍﻭل ﻭ ﺭﺒﻁ ﻫﺫﻩ ﺍﻟﺠﺩﺍﻭل ﺒﻌﻼﻗﺎﺕ ﻜﻤﺎ ﻴﺘﻭﻓﺭ ﻓﻴﻬﺎ ﻤﺠﻤﻭﻋﺔ ﻤﻥ‬
‫ﺍﻟﻭﻅﺎﺌﻑ ﺍﻟﻤﺴﺎﻋﺩﺓ ﻋﻠﻰ ﺘﺴﻬﻴل ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻫﺫﻩ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻭﻤﻊ ﺃﻥ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ﺘﻌﺘﺒﺭ ﺨﻴﺎﺭﺍ ﻤﻤﺘﺎﺯﺍ ﻓﻲ ﻜﺜﻴﺭ ﻤﻥ ﺍﻟﺤﺎﻻﺕ ﺇﻻ ﺃﻨﻬﺎ ﻗﺩ ﻻ ﺘﻜﻭﻥ ﺤﻼ ﻤﺜﺎﻟﻴﺎ ﻓﻲ ﺤﺎﻻﺕ ﺃﺨﺭﻯ ﻤﺜل‬
‫ﺃﻥ ﺘﺭﻴﺩ ﻗﺭﺍﺀﺓ ﺒﻴﺎﻨﺎﺕ ﻤﻥ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻘﻁ‪.‬‬
‫‪DataSet‬‬ ‫‪Tables‬‬
‫‪DataTable‬‬ ‫‪DataView‬‬
‫)‪DataRow(s‬‬
‫‪Relations‬‬ ‫‪DataColumn‬‬
‫‪DataRelation‬‬ ‫)‪Constraint(s‬‬ ‫‪DataViewManager‬‬
‫‪DataRelation‬‬
‫‪DataTable‬‬
‫‪DataTable‬‬
‫ﺤﺴﺏ ﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل ﻴﻤﻜﻥ ﺘﻘﺴﻴﻡ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻟﻰ ‪:‬‬

‫‪ .a‬ﺠﺩﻭل ﺒﻴﺎﻨﺎﺕ ‪ : DataTable‬ﻋﺒﺎﺭﺓ ﻋﻥ ﺘﻤﺜﻴل ﻟﺠﺩﻭل ﺇﻤﺎ ﺃﻥ ﺘﻘﻭﻡ ﺒﺒﻨﺎﺀ ﻫﻴﻜﻠﻪ ﺃﻭ‬
‫ﺘﺄﺨﺫﻩ ﻤﻥ ﻤﺼﺩﺭ ﺒﻴﺎﻨﺎﺕ‪ .‬ﻴﻤﻜﻥ ﺃﻥ ﺘﺤﺘﻭﻱ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻋﻠﻰ ﻋﺩﺩ ﻏﻴﺭ‬
‫ﻤﺤﺩﻭﺩ ﻤﻥ ﺍﻟﺠﺩﺍﻭل‪.‬‬
‫‪ .b‬ﺃﻋﻤﺩﺓ ‪ : DataColumn‬ﻋﺒﺎﺭﺓ ﻋﻥ ﺘﻤﺜﻴل ﻟﻌﺎﻤﻭﺩ ﺩﺍﺨل ﺠﺩﻭل ﻫﺫﺍ ﺍﻟﻌﺎﻤﻭﺩ ﻟﻪ‬
‫ﻨﻭﻉ ﻭ ﺍﺴﻡ ﻭﻁﻭل ﻭ ﻏﻴﺭ ﺫﻟﻙ ﻤﻥ ﻤﻭﺍﺼﻔﺎﺕ ﺍﻷﻋﻤﺩﺓ ﻜﻤﺎ ﻴﻭﺠﺩ ﻓﻲ ﻗﻭﺍﻋﺩ‬
‫‪159‬‬
‫‪ .c‬ﺼﻔﻭﻑ ‪ : DataRow‬ﻭﻫﻲ ﺼﻔﻭﻑ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬

‫‪ .d‬ﺍﻟﻘﻴﻭﺩ ‪ : DataConstarint‬ﻗﻴﻭﺩ ﺘﻭﻀﻊ ﻋﻠﻰ ﺍﻷﻋﻤﺩﺓ ﻤﺜل ‪Unique‬‬
‫‪ Constraint‬ﻗﻴﺩ ﻋﺩﻡ ﺍﻟﺘﻜﺭﺍﺭ ﺃﻭ ﻗﻴﺩ ﻋﺩﻡ ﻗﺎﺒﻠﻴﺔ ﻗﻴﻤﺔ ‪.Null‬‬
‫‪ .e‬ﺍﻟﻌﻼﻗﺎﺕ ‪ : DataRelation‬ﺒﻌﺩ ﺇﻨﺸﺎﺀ ﺍﻟﺠﺩﺍﻭل ﺘﺴﺘﻁﻴﻊ ﻤﻥ ﺨﻼل ﻫﺫﺍ ﺍﻟﻜﺎﺌﻥ‬
‫ﺇﻨﺸﺎﺀ ﻋﻼﻗﺎﺕ ﺒﻴﻥ ﻫﺫﻩ ﺍﻟﺠﺩﺍﻭل‪.‬‬
‫‪ .f‬ﺍﻟﻤﺴﺘﻌﺭﻀﺎﺕ ‪ : DataView‬ﺘﺴﺘﻁﻴﻊ ﺇﻨﺸﺎﺀ ﻤﺴﺘﻌﺭﺽ ﻋﻠﻰ ﺠﺩﻭل ﺃﻭ ﺃﻜﺜﺭ ﻤﻥ‬
‫ﺨﻼل ﻫﺫﺍ ﺍﻟﻜﺎﺌﻥ‪.‬‬
‫ﻤﻼﺤﻅﺎﺕ ﻋﺎﻤﺔ ﻫﺎﻤﺔ ﺤﻭل ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫• ﻴﻤﻜﻥ ﺃﻥ ﺘﺤﺘﻭﻱ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻋﺩﺩ ﻏﻴﺭ ﻤﺤﺩﻭﺩ ﻤﻥ ﺍﻟﺠﺩﺍﻭل‪.‬‬

‫• ﺃﻗﺭﺏ ﻤﺎ ﻴﻤﻜﻥ ﺘﺸﺒﻴﻬﺎ ﺒـ ‪RecordSet‬‬
‫• ﺘﺘﺼل ﺒﻘﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﺨﻼل ‪DataAdaptor‬‬
‫• ﺘﺴﺘﻁﻴﻊ ﺇﻀﺎﻓﺔ ﺍﻟﺠﺩﺍﻭل ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻭﺍﺤﺩﺓ ﻤﻥ ﻤﺼﺎﺩﺭ ﻤﺘﻨﻭﻋﺔ‬
‫‪ MySQL,Oracle..‬ﺜﻡ ﺭﺒﻁﻬﺎ ﻤﻊ ﺒﻌﺽ‬
‫• ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﻴﺱ ﻟﻬﺎ ﻤﺯﻭﺩ ﺒﻴﺎﻨﺎﺕ ﻤﺤﺩﺩ ﺒل ﻫﻲ ﻋﺎﻤﺔ ﻟﺠﻤﻴﻊ ﻤﺯﻭﺩﻱ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫• ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﺘﺴﻠﺴﻠﺔ ‪ : Serializable‬ﺘﺤﻭل ﺇﻟﻰ ﺍﻜﺱ ﺍﻡ ﺍل ﻭ ﺍﻟﻌﻜﺱ‬
‫‪ -٢‬ﻤﻬﻲﺀ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ : Data Adaptor‬ﻴﻘﻭﻡ ﻫﺫﺍ ﺍﻟﻜﺎﺌﻥ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺜﻼﺜﺔ ﻜﺎﺌﻨﺎﺕ ﺒﺎﻁﻨﻴﺎ ﻭﻫﻲ ﻗﺎﺭﺉ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﻜﺎﺌﻥ ﺍﻷﻤﺭ ﻭ ﻜﺎﺌﻥ ﺍﻻﺘﺼﺎل‪ .‬ﻴﻘﻭﻡ ﺒﻔﺘﺢ ﺍﻻﺘﺼﺎل ﺒﻤﺼﺩﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻋﻥ ﻁﺭﻴﻕ ﻜﺎﺌﻥ‬
‫ﺍﻻﺘﺼﺎل ﺜﻡ ﺍﺴﺘﺨﺩﺍﻡ ﻜﺎﺌﻥ ﺍﻷﻤﺭ ﻟﺘﻨﻔﻴﺫ ﻋﻤﻠﻴﺔ ﻤﺎ ﺜﻡ ﻗﺎﺭﺉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﻘﺭﺍﺀﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﺘﻌﺒﺌﺘﻬﺎ ﻓﻲ‬
‫ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫‪160‬‬
‫ﺩﻭﺭﺓ ﺍﻟﺤﻴﺎﺓ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬

‫ﺘﺼﻭﺭ ﺩﻭﺭﺓ ﺍﻟﺤﻴﺎﺓ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻴﺴﺎﻋﺩ ﻋﻠﻰ ﻓﻬﻤﻬﺎ ﻓﻬﻤﺎ ﺩﻗﻴﻘﺎ ﻭﻤﻥ ﺜﻡ ﻴﺴﻬل ﺍﻟﺘﻌﺎﻤل ﻤﻌﻬﺎ‪.‬‬
‫ﻴﻤﻜﻥ ﺘﻘﺴﻴﻡ ﻤﺭﺍﺤل ﺍﻟﺘﻌﺎﻤل ﻤﻊ‬
‫ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻟﻰ ﺍﻟﺨﻁﻭﺍﺕ‬
‫ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫‪ -١‬ﺘﻌﺒﺌﺔ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﻭﺍﺴﻁﺔ ﻤﻬﻲﺀ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪ -٢‬ﺭﺒﻁ ﺍﻟﺠﺩﺍﻭل ﺒﻌﻼﻗﺎﺕ ﺇﻥ ﻜﺎﻥ ﻫﻨﺎﻙ ﺍﺤﺘﻴﺎﺝ‪.‬‬
‫‪ -٣‬ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪ -٤‬ﺍﻟﺘﺄﺜﻴﺭ ﻋﻠﻰ ﻗﻭﺍﻋﺩ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﻭﺍﺴﻁﺔ ﻤﻬﺊ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪DataSet‬‬
‫‪Table1‬‬
‫ﺍﺴﺘﺨﺭﺍﺝ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻋﻥ‬
‫‪Original‬‬ ‫ﻁﺭﻴﻕ ‪Adaptor‬‬
‫‪DataStore‬‬
‫‪Table2‬‬
‫ﺍﻟﺘﺄﺜﻴﺭ ﻋﻠﻰ ﻗﻭﺍﻋﺩ‬ ‫ﺍﻨﺸﺎﺀ ﺍﻟﻌﻼﻗﺎﺕ‬

‫ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫‪DataSet‬‬ ‫‪DataSet‬‬
‫‪Table1‬‬
‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫‪Table1‬‬
‫‪Table2‬‬
‫‪Table2‬‬
‫ﻴﻭﺠﺩ ﻫﻨﺎﻙ ﻁﺭﻴﻘﺘﺎﻥ ﻟﻠﺘﻌﺎﻤل ﻤﻊ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪:‬‬

‫‪ -١‬ﺇﻨﺸﺎﺀ ﻫﻴﻜل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺭﻤﺠﻴﺎ ‪ :‬ﺃﻥ ﺘﻘﻭﻡ ﺒﺈﻨﺸﺎﺀ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﺇﻨﺸﺎﺀ ﺍﻟﺠﺩﺍﻭل ﻭ‬
‫ﺍﻷﻋﻤﺩﺓ ﻭ ﺍﻟﻌﻼﻗﺎﺕ ﺒﻨﻔﺴﻙ ﻭﻤﻥ ﺜﻡ ﺇﻀﺎﻓﺘﻬﺎ ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪ -٢‬ﺒﻨﺎﺀ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﻫﻴﻜل ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ :‬ﺃﻥ ﺘﺤﻀﺭ ﻫﻴﻜل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﻗﻭﺍﻋﺩ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﺘﺒﻨﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﻨﺎﺀ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﻬﻴﻜل‪.‬‬
‫‪161‬‬
‫ﺇﻨﺸﺎﺀ ﻫﻴﻜل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺭﻤﺠﻴﺎ‬

‫ﺘﻌﺘﺒﺭ ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﻗﻠﻴﻠﺔ ﺍﻻﺴﺘﺨﺩﺍﻡ ﻷﻥ ﺃﻏﻠﺏ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﺘﻘﻭﻡ ﺒﻤلﺀ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﻗﺎﻋﺩﺓ‬
‫ﺒﻴﺎﻨﺎﺕ ﻭﻫﻭ ﻤﺎ ﻴﻌﻨﻲ ﺇﺤﻀﺎﺭ ﻫﻴﻜل ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﺴﻭﻑ ﺘﺴﺎﻋﺩﻙ ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﻋﻠﻰ ﻓﻬﻡ ﻗﺭﻴﺏ ﻟﻤﺠﻤﻭﻋﺔ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ .‬ﺴﻭﻑ ﻨﻨﺸﺊ ﻫﻴﻜل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﺍﻟﺨﻁﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ -١‬ﺍﻟﺨﻁﻭﺓ ﺍﻷﻭﻟﻰ ﻫﻲ ﺇﻨﺸﺎﺀ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻹﻨﺸﺎﺀ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ ﺒﺭﻤﺠﻴﺎ ﻗﻡ ﺒﻜﺘﺎﺒﺔ‬
‫ﺍﻷﻤﺭ ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫)(‪Dim dsTelDir As New DataSet‬‬
‫ﻴﻘﻭﻡ ﺍﻷﻤﺭ ﺍﻟﺴﺎﺒﻕ ﺒﺈﻨﺸﺎﺀ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ ﺍﺴﻤﻬﺎ ‪.dsTelDir‬‬
‫‪ -٢‬ﺍﻟﺨﻁﻭﺓ ﺍﻟﺜﺎﻨﻴﺔ ﺇﻨﺸﺎﺀ ﺠﺩﻭل ﺜﻡ ﺇﻀﺎﻓﺘﻪ ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﺴﺒﻕ ﺇﻨﺸﺎﺌﻬﺎ‪ .‬ﻹﻨﺸﺎﺀ‬
‫ﺠﺩﻭل ﻭ ﺇﻀﺎﻓﺘﻪ ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻗﻡ ﺒﻤﺎ ﻴﻠﻲ‪:‬‬
‫)(‪Dim dtPerson As DataTable = dsTelDir.Tables.Add‬‬
‫ﻓﻲ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ ﻗﻤﻨﺎ ﺒﺈﻀﺎﻓﺔ ﺠﺩﻭل ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﺃﻨﺸﺄﻨﺎﻫﺎ ﺤﺩﻴﺜﺎ ﺜﻡ ﺃﺴﻨﺩﻨﺎ ﻫﺫﺍ‬
‫ﺍﻟﺠﺩﻭل ﺇﻟﻰ ﺠﺩﻭل ﺃﻨﺸﺄﻨﺎﻩ ﻭ ﺍﺴﻤﻪ ‪ . dtPerson‬ﻋﻨﺩ ﺇﻀﺎﻓﺔ ﺠﺩﻭل ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ ﻭ ﻋﺩﻡ‬
‫ﺘﺴﻤﻴﺘﻪ ﻓﺈﻨﻪ ﻴﺄﺨﺫ ﺍﺴﻡ ‪ TableX‬ﻭ ﺍﻟﻌﺩﺩ ﺍﻜﺱ ﻫﻭ ﺘﺼﺎﻋﺩﻱ ﺤﺴﺏ ﻋﺩﺩ ﺍﻟﺠﺩﺍﻭل ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ‬
‫ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪ -٣‬ﺍﻟﺨﻁﻭﺓ ﺍﻟﺜﺎﻟﺜﺔ ﻫﻲ ﺇﻀﺎﻓﺔ ﻋﺎﻤﻭﺩ ﺇﻟﻰ ﺠﺩﻭل ﺩﺍﺨل ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﺍﻷﻤﺭ ﺍﻟﺘﺎﻟﻲ ﻴﻘﻭﻡ‬
‫ﺒﺈﻨﺸﺎﺀ ﻋﺎﻤﻭﺩ ﻭﻤﻥ ﺜﻡ ﺇﻀﺎﻓﺘﻪ ﺇﻟﻰ ﺠﺩﻭل ‪:‬‬
‫))‪Dim colName As DataColumn = dtPerson.Columns.Add("Name", GetType(System.String‬‬
‫‪colName.AllowDBNull = False‬‬
‫‪colName.Unique = True‬‬
‫ﻓﻲ ﺍﻟﺨﻁﻭﺓ ﺍﻟﺴﺎﺒﻘﺔ ﻗﻤﻨﺎ ﺒﻤﺎ ﻴﻠﻲ ‪:‬‬

‫‪ .a‬ﺇﻀﺎﻓﺔ ﻋﺎﻤﻭﺩ –ﺤﻘل‪ -‬ﻭﻋﻴﻨﺎ ﻟﻪ ﺍﺴﻡ ‪ Name‬ﻭ ﻨﻭﻉ ‪.String‬‬
‫‪ .b‬ﻭﻀﻌﻨﺎ ﻗﻴﺩ ﻤﻨﻊ ﺇﺩﺨﺎل ﻗﻴﻡ ‪Null‬‬
‫‪ .c‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻟﺙ ﺍﺴﺘﺨﺩﻤﻨﺎ ﻗﻴﺩ ﻭﺤﻴﺩ ‪ Unique‬ﻟﻤﻨﻊ ﺘﻜﺭﺍﺭ ﻨﻔﺱ ﺍﻟﻘﻴﻤﺔ‪.‬‬
‫ﺴﻭﻑ ﻨﺤﺎﻭل ﺘﻁﺒﻴﻕ ﻜل ﺍﻟﺨﻁﻭﺍﺕ ﺍﻟﺴﺎﺒﻘﺔ ﻤﻥ ﺨﻼل ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ‪:‬‬

‫)(‪Dim dsTelDir As New DataSet‬‬
‫)(‪Dim dtPerson As DataTable = dsTelDir.Tables.Add‬‬
‫‪Dim colName As DataColumn = dtPerson.Columns.Add("Name",‬‬
‫))‪GetType(System.String‬‬
‫‪162‬‬
‫‪colName.AllowDBNull = False‬‬
‫‪colName.Unique = True‬‬
‫)‪MessageBox.Show(dtPerson.TableName‬‬
‫))(‪MessageBox.Show(dsTelDir.Tables.Count.ToString‬‬
‫ﻓﻲ ﻫﺫﺍ ﺍﻟﻤﺜﺎل ﻁﺒﻘﻨﺎ ﻜل ﺍﻟﺨﻁﻭﺍﺕ ﺍﻟﺴﺎﺒﻘﺔ ﺜﻡ ﺃﻅﻬﺭﻨﺎ ﺭﺴﺎﻟﺘﺎﻥ ‪:‬‬
‫‪ -١‬ﺍﻟﺭﺴﺎﻟﺔ ﺍﻷﻭﻟﻰ ﻨﻘﻭﻡ ﺒﻌﺭﺽ ﺍﺴﻡ ﺍﻟﺠﺩﻭل‪.‬‬
‫‪ -٢‬ﺍﻟﺭﺴﺎﻟﺔ ﺍﻟﺜﺎﻨﻴﺔ ﻨﻘﻭﻡ ﻓﻴﻬﺎ ﺒﻌﺭﺽ ﻋﺩﺩ ﺍﻟﺠﺩﺍﻭل ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫ﺇﻨﺸﺎﺀ ﻗﻴﺩ ﺍﻟﻤﻔﺘﺎﺡ ﺍﻟﺭﺌﻴﺴﻲ‬

‫ﺘﺤﻭﻱ ﺍﻟﺠﺩﺍﻭل ﻓﻲ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻋﻠﻰ ﻋﺎﻤﻭﺩ ﺃﻭ ﺃﻜﺜﺭ ﻻ ﻴﻤﻜﻥ ﺃﻥ ﺘﺘﻜﺭﺭ ﻗﻴﻤﺘﻪ ﻓﻲ‬
‫ﺃﻱ ﺼﻑ ﻤﻥ ﺼﻔﻭﻑ ﺍﻟﺠﺩﻭل‪ .‬ﻤﻥ ﺃﻤﺜﻠﺔ ﺍﻟﻤﻔﺘﺎﺡ ﺍﻟﺭﺌﻴﺴﻲ ‪:‬‬
‫‪ -١‬ﺭﻗﻡ ﺍﻟﻤﻭﻅﻑ ﻓﻲ ﺠﺩﻭل ﺍﻟﻤﻭﻅﻔﻴﻥ‬
‫‪ -٢‬ﺭﻤﺯ ﺍﻟﺼﻨﻑ ﻓﻲ ﺠﺩﻭل ﺍﻷﺼﻨﺎﻑ‬
‫ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﻜﻴﻔﻴﺔ ﺇﻨﺸﺎﺀ ﻗﻴﺩ ﺍﻟﻤﻔﺘﺎﺡ ﺍﻟﺭﺌﻴﺴﻲ ‪:‬‬

‫)(‪Dim myTable As DataTable = New DataTable‬‬
‫‪Dim myColumn As DataColumn‬‬
‫)(‪myColumn = New DataColumn‬‬
‫)"‪myColumn.DataType = System.Type.GetType("System.String‬‬
‫"‪myColumn.ColumnName = "FirstName‬‬
‫)‪myTable.Columns.Add(myColumn‬‬
‫})"‪myTable.PrimaryKey = New DataColumn() {myTable.Columns("FirstName‬‬
‫ﻴﻤﻜﻥ ﺸﺭﺡ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﺒﺎﻟﺨﻁﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ -١‬ﺃﻨﺸﺄﻨﺎ ﺠﺩﻭل ﺜﻡ ﺃﻨﺸﺄﻨﺎ ﻋﺎﻤﻭﺩ‪.‬‬
‫‪ -٢‬ﺤﺩﺩﻨﺎ ﻨﻭﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﺍﺴﻡ ﺍﻟﻌﺎﻤﻭﺩ‬
‫‪ -٣‬ﻗﻤﻨﺎ ﺒﺈﻀﺎﻓﺔ ﺍﻟﻌﺎﻤﻭﺩ ﺇﻟﻰ ﺍﻟﺠﺩﻭل‬
‫‪ -٤‬ﻗﻤﻨﺎ ﺒﺘﺤﺩﻴﺩ ﺍﻟﻤﻔﺘﺎﺡ ﺍﻟﺭﺌﻴﺴﻲ ﻤﻥ ﺨﻼل ﺍﻟﻌﺒﺎﺭﺓ ‪:‬‬
‫})"‪myTable.PrimaryKey = New DataColumn() {myTable.Columns("FirstName‬‬
‫ﺇﻨﺸﺎﺀ ﻋﺒﺎﺭﺍﺕ ﺭﻴﺎﻀﻴﺔ‬

‫ﻗﺩ ﺘﺤﺘﺎﺝ ﺃﻥ ﺘﻌﺭﺽ ﺤﻘل ﻴﻜﻭﻥ ﻨﺘﻴﺠﺔ ﺤﺴﺎﺒﺎﺕ ﻟﺤﻘﻭل ﺃﺨﺭﻯ‪ ،‬ﻤﺜل ﺃﻥ ﻴﻜﻭﻥ ﺍﻟﺤﻘل ﺍﻷﻭل ﻴﻤﺜل‬
‫ﺩﺭﺠﺔ ﺍﻻﺨﺘﺒﺎﺭ ﺍﻷﻭل ﻭ ﺍﻟﺤﻘل ﺍﻟﺜﺎﻨﻲ ﻴﻤﺜل ﺩﺭﺠﺔ ﺍﻻﺨﺘﺒﺎﺭ ﺍﻟﺜﺎﻨﻲ ﺜﻡ ﻫﻨﺎﻙ ﺤﻘل ﻴﻤﺜل ﻤﺠﻤﻭﻉ‬
‫‪163‬‬
‫ﺍﻟﺩﺭﺠﺎﺕ‪ .‬ﻫﺫﺍ ﺍﻟﺤﻘل ﻴﻤﺜل ﺒﻌﺎﻤﻭﺩ ﻴﺄﺨﺫ ﻗﻴﻤﻪ ﻤﻥ ﺍﻟﺤﺴﺎﺒﺎﺕ ﻭ ﻻ ﻴﻜﻭﻥ ﻟﻪ ﻋﺎﻤﻭﺩ ﻤﻤﺎﺜل ﻓﻲ‬
‫ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻏﺎﻟﺒﺎ‪ .‬ﻴﻤﻜﻥ ﺇﻀﺎﻓﺘﻪ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺨﺎﺼﻴﺔ ‪ Expression‬ﻭﻫﻲ ﺃﺤﺩ ﺨﺼﺎﺌﺹ‬
‫ﺍﻟﻜﺎﺌﻥ ‪.DataColumn‬‬
‫ﻟﻨﻨﻅﺭ ﺇﻟﻰ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﺍﻟﺫﻱ ﺴﻭﻑ ﻴﺒﺭﺯ ﺍﻟﻔﻜﺭﺓ ‪:‬‬

‫))‪Dim ColUnitPrice As New DataColumn("Price", GetType(System.Decimal‬‬
‫))‪Dim ColQuantity As New DataColumn("Quantity", GetType(System.Decimal‬‬
‫))‪Dim TotalCost As New DataColumn("Total", GetType(System.Decimal‬‬
‫)(‪Dim mytable As New DataTable‬‬
‫"‪TotalCost.Expression = "Price * Quantity‬‬
‫)‪mytable.Columns.Add(ColUnitPrice‬‬
‫)‪mytable.Columns.Add(ColQuantity‬‬
‫)‪mytable.Columns.Add(TotalCost‬‬
‫‪Dim myRow As DataRow‬‬
‫)(‪myRow = mytable.NewRow‬‬
‫‪myRow("Price") = 5‬‬
‫‪myRow("Quantity") = 1‬‬
‫)‪mytable.Rows.Add(myRow‬‬
‫)‪Label2.Text = mytable.Rows(0).Item(2‬‬
‫ﻴﻤﻜﻥ ﺘﻭﻀﻴﺢ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﺒﺎﻟﺨﻁﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫‪ -١‬ﺘﻌﺭﻴﻑ ﺜﻼﺜﺔ ﺃﻋﻤﺩ ﻭﻫﻲ ‪ ColUnitPrice‬ﻭ ‪ ColQuantity‬ﻭ ‪TotalCost‬‬
‫‪ -٢‬ﺘﻌﺭﻴﻑ ﺠﺩﻭل‬
‫‪ -٣‬ﻗﻤﻨﺎ ﺒﺘﻌﺭﻴﻑ ﺍﻟﻌﺎﻤﻭﺩ ‪ TotalCost‬ﺒﺄﻨﻪ ﻋﺒﺎﺭﺓ ﺭﻴﺎﻀﻴﺔ ﻭ ﻋﻴﻨﺎ ﻟﻪ ﻗﻴﻤﺔ * ‪Price‬‬
‫‪ Quantity‬ﻭﻫﻭ ﺤﺎﺼل ﻀﺭﺏ ﺍﻟﻌﺎﻤﻭﺩﻴﻥ ﺍﻵﺨﺭﻴﻥ‪.‬‬
‫‪ -٤‬ﺃﻀﻔﻨﺎ ﺍﻷﻋﻤﺩﺓ ﺇﻟﻰ ﺍﻟﺠﺩﻭل‬
‫‪ -٥‬ﻗﻤﻨﺎ ﺒﺘﻌﺭﻴﻑ ﺼﻑ ﺠﺩﻴﺩ‬
‫‪ -٦‬ﻋﻴﻨﺎ ﻟﻬﺫﺍ ﺍﻟﺼﻑ ﻗﻴﻤﺔ ﻭﻫﻲ ﺼﻑ ﺠﺩﻴﺩ ﻤﻥ ﺍﻟﺠﺩﻭل ﺍﻟﺫﻱ ﻴﺤﻭﻱ ﺜﻼﺜﺔ ﺤﻘﻭل ﻭ ﺒﺎﻟﺘﺎﻟﻲ ﻓﺈﻥ‬
‫ﻫﺫﺍ ﺍﻟﺼﻑ ﺴﻭﻑ ﻴﺘﻜﻭﻥ ﻤﻥ ﺜﻼﺙ ﻗﻴﻡ ﻫﻲ ‪ ٥‬ﻭ ‪ ١‬ﻭﻨﺘﻴﺠﺔ ﻀﺭﺒﻬﻤﺎ‪.‬‬
‫‪ -٧‬ﺃﻀﻔﻨﺎ ﻗﻴﻤﺔ ‪ ٥‬ﻟﻠﺴﻌﺭ ﻭ ‪ ١‬ﻟﻠﻜﻤﻴﺔ‪.‬‬
‫‪ -٨‬ﻗﻤﻨﺎ ﺒﺈﻀﺎﻓﺔ ﻫﺫﺍ ﺍﻟﺼﻑ ﻟﻠﺠﺩﻭل‬
‫‪ -٩‬ﻗﻤﻨﺎ ﺒﻌﺭﺽ ﺍﻟﻌﻨﺼﺭ ﺍﻟﺜﺎﻟﺙ –ﻤﺠﻤﻭﻉ ﺍﻟﺘﻜﻠﻔﺔ‪ -‬ﻋﻠﻰ ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ ﻭ ﺴﻭﻑ ﺘﻜﻭﻥ ﻗﻴﻤﺘﻪ ‪٥‬‬
‫ﻷﻨﻪ ﺘﻡ ﺤﺴﺎﺒﻬﺎ ﺒﻨﺎﺀ ﻋﻠﻰ ﺍﻟﻤﻌﺎﺩﻟﺔ ﺍﻟﺘﻲ ﺃﻨﺸﺄﻨﺎﻫﺎ‪.‬‬
‫‪164‬‬
‫ﺒﻨﺎﺀ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﻫﻴﻜل ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬

‫ﻟﺒﻨﺎﺀ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ ﺒﻨﺎﺀ ﻋﻠﻰ ﻗﺎﻋﺩﺓ ﺒﻴﺎﻨﺎﺕ ﻴﻭﺠﺩ ﻫﻨﺎﻙ ﻁﺭﻴﻘﺘﺎﻥ ‪:‬‬
‫‪ -١‬ﺍﺴﺘﺨﺩﺍﻡ ﻭﺍﺠﻬﺔ ﺘﻁﻭﻴﺭ ﺍﻟﺩﻭﺕ ﻨﺕ‪.‬‬
‫‪ -٢‬ﺒﻨﺎﺀ ﺫﻟﻙ ﺒﺭﻤﺠﻴﺎ‪.‬‬
‫ﺍﺴﺘﺨﺩﺍﻡ ﻭﺍﺠﻬﺔ ﺘﻁﻭﻴﺭ ﺍﻟﺩﻭﺕ ﻨﺕ‬

‫ﺘﻌﺘﺒﺭ ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﻤﻥ ﺍﻟﻁﺭﻕ ﺍﻟﺴﺭﻴﻌﺔ ﻟﻠﻭﺼﻭل ﺇﻟﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻤﻥ ﺜﻡ ﺒﻨﺎﺀ ﻭﺍﺠﻬﺎﺕ‬
‫ﺘﺘﻌﺎﻤل ﻤﻊ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﺍﺴﺘﺨﺩﺍﻡ ﻤﺴﺎﻋﺩ ﺇﻨﺸﺎﺀ ﺍﻟﻨﻤﺎﺫﺝ ﻴﻌﺘﺒﺭ ﻁﺭﻴﻘﺔ ﺠﻴﺩﺓ ﻟﻤﺎ ﻴﺴﻤﻰ‬
‫ﺒﺎﻟﻨﻤﺫﺠﺔ –‪ .-Prototype‬ﻓﻲ ﺍﻟﺒﺩﺍﻴﺔ ﻻﺒﺩ ﻤﻥ ﺇﻨﺸﺎﺀ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻴﺘﻡ ﻜﺎﻟﺘﺎﻟﻲ ‪:‬‬
‫‪ -١‬ﻗﻡ ﺒﺈﻨﺸﺎﺀ ﺍﻻﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ .TelDir‬ﻤﻥ ﺨﻼل ﻨﺎﻓﺫﺓ ﻤﺴﺘﻜﺸﻑ ﺍﻟﺨﺎﺩﻡ ﻜﻤﺎ ﻴﻅﻬﺭ‬
‫ﻓﻲ ﺍﻟﺸﻜل‬
‫‪ -٢‬ﻗﻡ ﺒﻨﻘﺭ ﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻷﻴﻤﻥ ﻋﻠﻰ ‪ Data Connection‬ﺜﻡ ﺍﺨﺘﺭ ‪.Add Connection‬‬
‫ﺴﻴﻅﻬﺭ ﻟﻙ ﺍﻟﺸﻜل ﺍﺨﺘﺭ ﺨﺎﻨﺔ ﻤﺯﻭﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ Provider‬ﺜﻡ ﺍﺨﺘﺭ ﺍﻟﻤﺯﻭﺩ ﺍﻟﺨﺎﺹ ﺒﺄﻜﺴﺱ ﻭﻫﻭ‬
‫‪ Microsoft.Jet.OLEDB.4‬ﺍﺨﺘﺭ ﺨﺎﻨﺔ ‪ Connection‬ﺜﻡ ﺍﺨﺘﺭ‬
‫ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪TelDir‬‬
‫‪165‬‬
‫‪ -٣‬ﺃﻨﺵﺀ ﻤﻬﻲﺀ ﺍﻟﺒﻴﺎﻨﺎﺕ )ﻭﺍﻟﺫﻱ ﻴﻭﺠﺩ ﻓﻲ ﺨﺎﻨﺔ ‪ Data‬ﻓﻲ ﻤﺭﺒﻊ ﺍﻷﺩﻭﺍﺕ ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ‬
‫ﺍﻟﺸﻜل( ﻭﺫﻟﻙ ﺒﺈﻀﺎﻓﺘﻪ ﺇﻟﻰ ﺍﻟﻨﻤﻭﺫﺝ‪.‬ﺴﻭﻑ ﺘﻅﻬﺭ ﻟﻙ ﺭﺴﺎﻟﺔ ﺘﺭﺤﻴﺏ‬
‫ﺍﻨﻘﺭ ﺍﻟﺘﺎﻟﻲ‪.‬‬
‫‪ -٤‬ﺴﻭﻑ ﺘﻅﻬﺭ ﻟﻙ ﺸﺎﺸﺔ ﺍﺨﺘﻴﺎﺭ ﺍﻻﺘﺼﺎل ﺍﻟﺫﻱ ﺘﺭﻴﺩ ﺍﺴﺘﺨﺩﺍﻤﻪ ﻗﻡ ﺒﺎﺨﺘﻴﺎﺭ ﺍﻻﺘﺼﺎل ﺍﻟﺫﻱ ﺘﻡ‬
‫ﺇﻨﺸﺎﺌﻪ ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل‪ .‬ﺜﻡ ﺍﻨﻘﺭ ﻋﻠﻰ ﺍﻟﺘﺎﻟﻲ‪.‬‬
‫‪ -٤‬ﺴﻭﻑ ﺘﻅﻬﺭ ﻟﻙ ﺸﺎﺸﺔ ﺘﻁﻠﺏ ﻤﻨﻙ ﺍﺨﺘﻴﺎﺭ ﻁﺭﻴﻘﺔ ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻓﻲ ﺤﺎﻟﺔ‬
‫ﻤﺎﻴﻜﺭﻭﺴﻭﻓﺕ ﺃﻜﺴﺱ ﻻ ﻴﻭﺠﺩ ﺇﻻ ﺍﻻﺨﺘﻴﺎﺭ ﺍﻷﻭل ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل‪ ،‬ﺍﻨﻘﺭ ﺍﻟﺘﺎﻟﻲ‪،‬‬
‫‪166‬‬
‫‪ -٥‬ﺴﻭﻑ ﺘﻅﻬﺭ ﻟﻙ ﺸﺎﺸﺔ ﺘﺴﺄﻟﻙ ﻋﻥ ﺠﻤﻠﺔ ‪ SQL‬ﺍﻟﺘﻲ ﺘﺭﻴﺩ ﺘﻨﻔﻴﺫﻫﺎ‪ .‬ﺍﻨﻘﺭ ﻋﻠﻰ ﺯﺭ‬
‫‪ QueryBuilder‬ﻹﻨﺸﺎﺀ ﺍﻟﺠﻤﻠﺔ ﺒﻁﺭﻴﻘﺔ ﺴﻬﻠﺔ‪ .‬ﺴﻭﻑ ﺘﻅﻬﺭ ﻟﻙ ﻗﺎﺌﻤﺔ ﺒﺎﻟﺠﺩﺍﻭل ﺍﻟﻤﻭﺠﻭﺩﺓ‬
‫ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻗﻡ ﺒﺎﺨﺘﻴﺎﺭ ﺍﻟﺠﺩﻭل ‪ Person‬ﺜﻡ ﺍﻨﻘﺭ ﻤﻭﺍﻓﻕ‪ .‬ﺴﻭﻑ ﺘﻅﻬﺭ‬
‫ﻟﻙ ﺤﻘﻭل ﻫﺫﺍ ﺍﻟﺠﺩﻭل ﻜﻤﺎ ﺘﺭﻯ ﻓﻲ ﺍﻟﺸﻜل ﺍﺨﺘﺭ ‪ Name،ID‬ﺜﻡ ﺍﻨﻘﺭ ﻤﻭﺍﻓﻕ‪.‬‬
‫ﺴﻭﻑ ﺘﺭﺠﻊ ﺇﻟﻰ ﺍﻟﺸﺎﺸﺔ ﺍﻷﻭﻟﻰ ﺍﻨﻘﺭ ﺍﻟﺘﺎﻟﻲ‪.‬‬
‫‪ -٦‬ﺴﻭﻑ ﻴﻅﻬﺭ ﻟﻙ ﺍﻟﺸﻜل ﻭ ﺍﻟﺫﻱ ﻴﺨﺒﺭﻙ ﺒﺄﻨﻪ ﺘﻡ ﺇﻨﺘﺎﺝ ﺠﻤﻴﻊ ﺃﻨﻭﺍﻉ ﺠﻤل‬
‫ﺍﻻﺴﺘﻔﺴﺎﺭ ﺍﻟﺒﻨﺎﺌﻴﺔ ﻟﻠﺠﺩﻭل ﺍﻟﺫﻱ ﺍﺨﺘﺭﺕ ﺍﻨﻘﺭ ﻋﻠﻰ ﺯﺭ ﺇﻨﻬﺎﺀ‪ .‬ﻻﺤﻅ ﺃﻨﻪ ﺘﻡ‬
‫ﺇﻨﺸﺎﺀ ﻜﺎﺌﻨﻲ ﺍﺘﺼﺎل ﻭ ﻤﻬﻲﺀ ﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪167‬‬
‫‪ -٧‬ﻹﻨﺸﺎﺀ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻗﻡ ﺒﺎﻟﻨﻘﺭ ﺒﺎﻟﺯﺭ ﺍﻷﻴﻤﻥ ﻋﻠﻰ ﻤﻬﻲﺀ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﻴﻅﻬﺭ ﻟﻙ ﺍﻟﺸﻜل‪ .‬ﺜﻡ‬
‫ﺍﺨﺘﺭ ‪Generate Data Set‬‬
‫‪ -٨‬ﺴﻭﻑ ﻴﻅﻬﺭ ﻟﻙ ﺍﻟﺸﻜل ﻭ ﺍﻟﺫﻱ ﻴﻁﻠﺏ ﻤﻨﻙ ﺃﻥ ﺘﺯﻭﺩﻩ ﺒﺎﺴﻡ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻗﻡ ﺘﺴﻤﻴﺘﻬﺎ‬
‫‪ dsPerson‬ﻜﻤﺎ ﻴﻅﻬﺭ ﻟﻙ ﻤﻥ ﺍﻟﺸﻜل‪ .‬ﻗﻡ ﺒﺈﺯﺍﻟﺔ ﻋﻼﻤﺔ ﺍﻻﺨﺘﻴﺎﺭ ﻋﻥ ‪Add This‬‬
‫‪ Dataset to The Designer‬ﺍﻨﻘﺭ ﻋﻠﻰ ﺯﺭ ﻤﻭﺍﻓﻕ ﺴﻭﻑ ﺘﻼﺤﻅ ﺃﻨﻪ ﺘﻡ ﺇﻀﺎﻓﺔ‬
‫ﻤﻠﻑ ‪ dsPerson.xsd‬ﺇﻟﻰ ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤﻠﻭل‪.‬‬
‫‪ -٩‬ﻟﺘﺤﻤﻴل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺃﻀﻑ ﺯﺭ ﺃﻤﺭ ﻋﻠﻰ ﺍﻟﻨﻤﻭﺫﺝ ﻭ‬
‫ﺃﻀﻑ ﺸﺒﻜﺔ ﺒﻴﺎﻨﺎﺕ ‪ Datagrid‬ﻤﻥ ﻤﺭﺒﻊ ﺍﻷﺩﻭﺍﺕ ﺜﻡ ﺃﻀﻑ ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ ﺩﺍﺨل ﺤﺩﺙ‬
‫‪168‬‬
‫ﺍﻟﻨﻘﺭ ﻟﺯﺭ ﺃﻤﺭ‬
‫)(‪Dim ds As New DataSet‬‬

‫)(‪Me.OleDbConnection1.Open‬‬
‫‪Try‬‬
‫)‪Me.OleDbDataAdapter1.Fill(ds‬‬
‫)‪DataGrid1.DataSource = ds.Tables(0‬‬
‫‪Catch Ex As OleDb.OleDbException‬‬
‫)‪MessageBox.Show(Ex.Message‬‬
‫‪End Try‬‬
‫)(‪Me.OleDbConnection1.Close‬‬
‫ﻓﻲ ﺍﻟﻜﻭﺩ ﺍﻟﺴﺎﺒﻕ ﻗﻡ ﺒﻤﺎ ﻴﻠﻲ ‪:‬‬

‫‪ -١‬ﻋﺭﻓﻨﺎ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ‬
‫‪ -٢‬ﻗﻤﻨﺎ ﺒﻔﺘﺢ ﺍﻻﺘﺼﺎل ﺍﻟﺫﻱ ﺴﺒﻕ ﻭﺃﻥ ﺃﻨﺸﺄﻨﺎﻩ‬
‫‪ -٣‬ﻗﻤﻨﺎ ﺒﻤلﺀ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﻭﺍﺴﻁﺔ ﻤﻬﻲﺀ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺫﻱ ﺴﺒﻕ ﺇﻨﺸﺎﺌﻪ‪.‬‬
‫‪ -٤‬ﺃﺭﺠﻌﻨﺎ ﺍﻟﺠﺩﻭل ﺭﻗﻡ ﺼﻔﺭ –ﺍﻟﺠﺩﻭل ﺍﻷﻭل‪ -‬ﺇﻟﻰ ‪ Datagrid‬ﻟﻴﺘﻡ ﻋﺭﻀﻪ‬
‫ﺒﻨﺎﺀ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺭﻤﺠﻴﺎ‬
‫‪169‬‬
‫ﺘﻌﺘﺒﺭ ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻷﻜﺜﺭ ﺸﻴﻭﻋﺎ ﻋﻨﺩ ﺍﺴﺘﺨﺩﺍﻡ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻴﻤﻜﻥ ﻤﻠﺊ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ﺩﻭﻥ ﺃﻥ ﺘﺤﺘﺎﺝ ﺇﻟﻰ ﺒﻨﺎﺀ ﻫﻴﻜل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻷﻥ ﻫﻴﻜل ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺘﻡ ﺘﻜﻭﻴﻨﻪ ﺒﻌﺩ ﺍﺴﺘﺭﺠﺎﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ‬
‫ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻗﻡ ﺒﺈﻀﺎﻓﺔ ﺍﻷﺩﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻭ ﺃﻋﻁﻬﺎ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫‪cmdFillGrid‬‬ ‫‪Name‬‬ ‫‪Button1‬‬
‫ﺇﺤﻀﺎﺭ ﻤﻌﻠﻭﻤﺎﺕ ﺍﻷﺸﺨﺎﺹ‬ ‫‪Text‬‬
‫‪Text‬‬
‫‪DataGrid1‬‬ ‫‪Name dataGrid‬‬
‫ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺭﻤﺠﻴﺎ‬ ‫‪Text‬‬ ‫‪Form1‬‬
‫‪Yes RightToLeft‬‬
‫ﻗﻡ ﺒﺈﻀﺎﻓﺔ ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ ﻓﻲ ﺤﺩﺙ ﺍﻟﻨﻘﺭ ﺍﻟﺨﺎﺹ ﺒﺯﺭ ﺍﻷﻤﺭ ‪:‬‬
‫)(‪Dim dsperson As New DataSet‬‬
‫"‪Dim sql As String = "select id,name from person‬‬
‫‪Try‬‬
‫)‪Dim da As New OleDb.OleDbDataAdapter(sql, con‬‬
‫)"‪da.Fill(dsperson, "Person‬‬
‫)"‪DataGrid1.DataSource = dsperson.Tables("Person‬‬
‫‪End Try‬‬
‫ﻤﻥ ﺍﻟﻜﻭﺩ ﺍﻟﺴﺎﺒﻕ ﻴﻤﻜﻥ ﺘﻭﻀﻴﺢ ﺍﻟﻨﻘﺎﻁ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫ﻋﺭﻓﻨﺎ ﺍﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺜﻡ ﻋﺭﻓﻨﺎ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ ﺜﻡ ﻋﺭﻓﻨﺎ ﺠﻤﻠﺔ ‪ sql‬ﺍﻟﺘﻲ ﻨﺭﻴﺩ‬ ‫‪-١‬‬
‫ﺃﻥ ﻨﺴﺘﺭﺠﻌﻬﺎ‪ ،‬ﺜﻡ ﻋﺭﻓﻨﺎ ﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل‪.‬‬
‫ﻗﻤﻨﺎ ﺒﺘﻌﺭﻴﻑ ﻤﻬﻲﺀ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﺃﻋﻁﻴﻨﺎﻩ ﻋﺎﻤﻼﻥ ﻫﻤﺎ ‪ :‬ﺍﻻﺘﺼﺎل ﺍﻟﺫﻱ ﺴﻴﺴﺘﺨﺩﻤﻪ‬ ‫‪-٢‬‬
‫ﻻﺴﺘﺭﺠﺎﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﺠﻤﻠﺔ ‪ sql‬ﺍﻟﺘﻲ ﻨﺭﻴﺩ ﺃﻥ ﻴﻨﻔﺫﻫﺎ‪.‬‬
‫ﻤﻠﺊ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﻨﺘﻴﺠﺔ ﺠﻤﻠﺔ ﺍﻻﺴﺘﻔﺴﺎﺭ ‪.sql‬‬ ‫‪-٣‬‬
‫ﻗﻤﻨﺎ ﺒﺈﺭﺠﺎﻉ ﺠﺩﻭل ﺍﻷﺸﺨﺎﺹ ﺇﻟﻰ ‪ Datagrid‬ﻟﻴﺘﻡ ﻋﺭﻀﻪ ﻜﻤﺎ ﻴﻅﻬﺭ ﻟﻙ ﻤﻥ ﺍﻟﺸﻜل‪.‬‬ ‫‪-٤‬‬
‫ﻻﺤﻅ ﺃﻨﻨﺎ ﻟﻡ ﻨﻘﻡ ﺒﻔﺘﺢ ﺍﻻﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻷﻥ ﻤﻬﻲﺀ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻴﻘﻭﻡ ﺒﺫﻟﻙ‪.‬‬
‫‪170‬‬
‫ﺘﻁﻭﻴﺭ ﻭﺍﺠﻬﺔ ﺍﻟﻨﻅﺎﻡ‬

‫ﺘﻌﺘﺒﺭ ﺸﺒﻜﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﺃﻫﻡ ﺃﺩﻭﺍﺕ ﻋﺭﺽ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﺍﻟﺘﻌﺎﻤل ﻤﻌﻬﺎ‪ .‬ﻟﺫﻟﻙ ﺴﻭﻑ ﻨﻘﻭﻡ ﺍﻵﻥ‬
‫ﺒﺎﺴﺘﻜﺸﺎﻑ ﻜﻴﻑ ﻴﻤﻜﻥ ﺃﻥ ﻨﻁﻭﺭ ﺸﻜل ﻋﺭﻀﻬﺎ ﻭ ﻜﻴﻔﻴﺔ ﺘﻌﺎﻤل ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻌﻬﺎ‪ .‬ﻟﻭ ﻨﻅﺭﻨﺎ‬
‫ﺇﻟﻰ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﻟﻭﺠﺩﻨﺎ ﺃﻨﻪ ﻗﺩ ﻅﻬﺭ ﻟﻨﺎ ﻋﻨﻭﺍﻥ ﻋﺎﻤﻭﺩ ﺭﻗﻡ ﺍﻟﻤﻭﻅﻑ ﻜﻤﺎ ﺠﺎﺀ ﻤﻥ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ﻤﺎﺫﺍ ﻟﻭ ﺃﺭﺩﺕ ﺃﻥ ﺘﻐﻴﺭ ﻫﺫﺍ ﺍﻻﺴﻡ ﻟﻴﻜﻭﻥ ﺒﺎﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ﻓﻴﻅﻬﺭ ﺭﻗﻡ ﺍﻟﻤﻭﻅﻑ ﺒﺩﻻ ﻤﻥ ‪ id‬ﻭ ﻴﻅﻬﺭ‬
‫ﺍﺴﻡ ﺍﻟﻤﻭﻅﻑ ﺒﺩﻻ ﻤﻥ ‪.Name‬‬
‫ﺘﺴﺘﻁﻴﻊ ﺃﻥ ﺘﻨﺸﻲﺀ ﺘﺼﻤﻴﻡ ﻟﺠﺩﺍﻭل ﻓﻲ ﺸﺒﻜﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻤﻥ ﺜﻡ ﺘﺠﻌل ﻫﺫﻩ ﺍﻟﺠﺩﺍﻭل ﻫﻲ ﻭﺍﺠﻬﺎﺕ ﺘﻠﻙ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻗﻡ ﺒﺎﻟﺨﻁﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻟﻜﻲ ﺘﻨﺸﺄ ﻤﻅﻬﺭ ﻟﺠﺩﻭل ‪Person‬‬
‫ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪: da‬‬
‫‪ -١‬ﺍﺫﻫﺏ ﺇﻟﻰ ﺨﺼﺎﺌﺹ ﺸﺒﻜﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﺘﺠﺩ ﺍﻟﺨﺎﺼﻴﺔ ‪ .TableStylas‬ﻭﺍﻀﻐﻁ ﺯ ‪‬ﺭ ﺍﻻﻨﺘﻘﺎل‬
‫ﺍﻟﻤﺠﺎﻭﺭ ﻟﻬﺎ‪ .‬ﺴﺘﻅﻬﺭ ﻟﻙ ﻨﺎﻓﺫﺓ ﺘﺤﺭﻴﺭ ﻤﺠﻤﻭﻋﺔ ﺃﻨﻤﺎﻁ ﺍﻟﺠﺩﺍﻭل‬
‫‪ -٢‬ﺍﻀﻐﻁ ﺯﺭ ﺍﻹﻀﺎﻓﺔ ‪ .Add‬ﺴﻴ‪‬ﻀﺎﻑ ﺍﻟﻜﺎﺌﻥ ‪DataGridTableStyle1‬‬

‫ﻟﻠﻤﺠﻤﻭﻋﺔ‪ .‬ﺴﻭﻑ ﻴﻜﻭﻥ ﻫﺫﺍ ﺍﻟﺠﺩﻭل ﻫﻭ ﻭﺍﺠﻬﺔ ‪ Person‬ﺍﻟﻤﻭﺠﻭﺩ ﻤﻥ ﻀﻤﻥ ﻤﺠﻤﻭﻋﺔ‬
‫‪171‬‬
‫‪ -٣‬ﺍﺨﺘﺭ ﺨﺎﺼﻴﺔ ‪ MappingName‬ﻗﻡ ﺒﻜﺘﺎﺒﺔ ‪ Person‬ﻭﻫﻭ ﺍﺴﻡ ﺍﻟﺠﺩﻭل ﻓﻲ ﻤﺠﻤﻭﻋﺔ‬

‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﺍﻟﺫﻱ ﺴﻭﻑ ﻴﻌﺭﺽ ﻤﻥ ﺨﻼل ﻫﺫﺍ ﺍﻟﺸﻜل‪..‬‬
‫‪ -٤‬ﻫﺫﻩ ﺍﻟﺨﻁﻭﺓ ﺴﻭﻑ ﺘﻘﻭﻡ ﺒﺭﺒﻁ ﺃﻋﻤﺩﺓ ﺍﻟﺠﺩﻭل ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻫﻨﺎ‬
‫ﻟﻨﺘﻤﻜﻥ ﻤﻥ ﺇﻋﻁﺎﺌﻬﺎ ﺨﺼﺎﺌﺹ ﻜﻤﺎ ﻨﺭﻴﺩ‪ .‬ﺍﻨﻘﺭ ﻋﻠﻰ ﺍﻟﻨﻘﺎﻁ ﺍﻟﺜﻼﺜﺔ ﺍﻟﻤﻘﺎﺒﻠﺔ ﻟﻬﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﻟﻴﻅﻬﺭ‬
‫ﻟﻙ ﺍﻟﺸﻜل‪ .‬ﺍﻀﻐﻁ ﺯﺭ ﺍﻹﻀﺎﻓﺔ ‪ Add‬ﻟﻴﺘﻡ ﺇﻀﺎﻓﺔ ‪ ، GridColumnStyle‬ﺍﺫﻫﺏ ﺇﻟﻰ‬
‫ﺍﻟﺨﺎﺼﻴﺔ ‪ MappingName‬ﻭ ﺍﻜﺘﺏ ‪ id‬ﻟﻴﺘﻡ ﺭﺒﻁ ﻫﺫﺍ ﺍﻟﻜﺎﺌﻥ ﺒﺎﻟﻌﺎﻤﻭﺩ ‪ id‬ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ‬
‫ﺍﻟﺠﺩﻭل ‪ Person‬ﺍﺫﻫﺏ ﺇﻟﻰ ﺨﺎﺼﻴﺔ ‪ HeaderText‬ﻭ ﺍﻜﺘﺏ ﺭﻗﻡ ﺍﻟﻤﻭﻅﻑ‪ ،‬ﻫﺫﺍ ﻫﻭ ﻤﺎ‬
‫ﺴﻴﻅﻬﺭ ﻋﻨﻭﺍﻨﺎ ﻟﻌﺎﻤﻭﺩ ﺭﻗﻡ ﺍﻟﻤﻭﻅﻑ ﻓﻲ ﺸﺒﻜﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﺃﻀﻑ ﻜﺎﺌﻨﺎ ﺁﺨﺭ ﻭ ﺍﺫﻫﺏ ﺇﻟﻰ‬
‫‪ MappingName‬ﻭ ﺍﻜﺘﺏ ‪.name‬ﺍﺫﻫﺏ ﺇﻟﻰ ﺨﺎﺼﻴﺔ ‪ HeaderText‬ﻭ ﺍﻜﺘﺏ ﺍﺴﻡ ﺍﻟﻤﻭﻅﻑ‪.‬‬
‫ﺍﻀﻐﻁ ‪ Ok‬ﺜﻡ ‪ Ok‬ﺜﻡ ﺸﻐل ﺍﻟﺒﺭﻨﺎﻤﺞ ﻟﻴﻅﻬﺭ ﻟﻙ ﺍﻟﺸﻜل‬
‫ﺭﺒﻁ ﺠﺩﻭﻟﻴﻥ ﺜﻡ ﻋﺭﻀﻬﻤﺎ ﻋﻠﻰ ﺸﺒﻜﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬

‫ﻤﺎﺫﺍ ﻟﻭ ﺃﺭﺩﺕ ﺃﻥ ﺘﻌﺭﺽ ﺍﻟﻤﻭﻅﻔﻴﻥ ﺜﻡ ﺒﻌﺩ ﺍﺨﺘﻴﺎﺭ ﻭﺍﺤﺩ ﻤﻨﻬﻤﺎ ﺘﻘﻭﻡ ﺒﻌﺭﺽ ﺃﺭﻗﺎﻡ ﻫﺎﺘﻔﻪ ﻜﻤﺎ ﻴﻅﻬﺭ‬
‫ﻤﻥ ﺍﻟﺸﻜل ‪ .‬ﻻﺤﻅ ﻜﻴﻑ ﺘﻡ ﻋﺭﺽ ﺍﺨﺘﻴﺎﺭ ﺃﺭﻗﺎﻡ ﺍﻟﻤﻭﻅﻑ ﺜﻡ ﻋﺭﻀﻬﺎ ﺒﺸﻜل ﺭﺃﺱ ﻭ ﺘﻔﺎﺼﻴل‪.‬‬
‫‪172‬‬
: ‫ﻗﻡ ﺒﺘﻐﻴﻴﺭ ﺍﻟﻜﻭﺩ ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﻟﻴﻜﻭﻥ ﻜﻤﺎ ﻴﻠﻲ‬

Dim Myds As New DataSet()
Dim sql(1) As String
sql(0) = "select id,name from person"
sql(1) = "select ID,Number,person from Phone"
Try
Dim daPerson As New OleDb.OleDbDataAdapter(sql(0), con)
Dim daPhone As New OleDb.OleDbDataAdapter(sql(1), con)
daPerson.Fill(Myds, "Person")
daPhone.Fill(Myds, "Phone")
Myds.Relations.Add("‫"اﳌﻮﻇﻒ هﺎﺗﻒ أرﻗﺎم‬," & _
"Myds.Tables("Person").Columns(0), Myds.Tables("Phone").Columns(2), True)
DataGrid1.DataSource = Myds
End Try
: ‫ﻟﺘﻭﻀﻴﺢ ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ ﺍﻓﻬﻡ ﺍﻟﺨﻁﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ‬
.‫ ﺘﻡ ﺘﻌﺭﻴﻑ ﺍﺘﺼﺎل ﺜﻡ ﺘﻌﺭﻴﻑ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ‬-١
‫ ﺍﻷﻭل ﻤﻥ‬،‫ ﺘﻡ ﺘﻌﺭﻴﻑ ﻤﺼﻔﻭﻓﺔ ﻤﻜﻭﻨﺔ ﻤﻥ ﺼﻔﻴﻥ ﻜل ﻭﺍﺤﺩ ﻤﻨﻬﻤﺎ ﻴﻤﺜل ﺠﻤﻠﺔ ﺍﺴﺘﻌﻼﻡ‬-٢
.‫ﺠﺩﻭل ﺍﻟﻤﻭﻅﻔﻴﻥ ﻭ ﺍﻟﺜﺎﻨﻲ ﻤﻥ ﺠﺩﻭل ﺃﺭﻗﺎﻡ ﺍﻟﻬﺎﺘﻑ‬
‫ ﻗﻤﻨﺎ ﺒﺘﻌﺭﻴﻑ ﻤﻬﻴﺌﺘﻲ ﺒﻴﺎﻨﺎﺕ ﺍﻷﻭﻟﻰ ﻟﺘﻨﻔﻴﺫ ﺍﻻﺴﺘﻌﻼﻡ ﺍﻟﺨﺎﺹ ﺒﺎﻟﻤﻭﻅﻔﻴﻥ ﺜﻡ ﻭﻀﻊ ﻨﺘﻴﺠﺘﻪ ﻓﻲ‬-٣
‫ ﻤﻬﻴﺌﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺜﺎﻨﻴﺔ ﺴﻭﻑ ﺘﻨﻔﺫ ﺍﻻﺴﺘﻌﻼﻡ‬،‫ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬Person ‫ﺠﺩﻭل ﺍﺴﻤﻪ‬
‫ﺍﻟﺜﺎﻨﻲ ﻭ ﺍﻟﺫﻱ ﻴﻘﻭﻡ ﺒﺎﺴﺘﺭﺠﺎﻉ ﺭﻗﻡ ﺍﻟﻤﻭﻅﻑ ﻭ ﺃﺭﻗﺎﻡ ﻫﻭﺍﺘﻔﻪ ﺜﻡ ﻭﻀﻌﻨﺎ ﺍﻟﻨﺘﻴﺠﺔ ﻓﻲ ﺠﺩﻭل‬
..Myds ‫ ﺩﺍﺨل ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬Phone ‫ﺍﺴﻤﻪ‬
173
‫‪ -٤‬ﻫﺫﻩ ﺍﻟﺨﻁﻭﺓ ﻫﻲ ﺍﻷﻫﻡ ﺤﻴﺙ ﻗﻤﻨﺎ ﺒﺭﺒﻁ ﺍﻟﺠﺩﻭﻟﻴﻥ ﺒﺒﻌﻀﻬﻤﺎ ﺍﻟﺒﻌﺽ ﻤﻥ ﺨﻼل ﺍﻟﻌﺎﻤﻭﺩ‬
‫ﺍﻷﻭل ﻓﻲ ﺠﺩﻭل ﺍﻟﻤﻭﻅﻔﻴﻥ ﻭ ﺍﻟﺫﻱ ﻴﻤﺜل ﺭﻗﻡ ﺍﻟﻤﻭﻅﻑ ﻭ ﺍﻟﻌﺎﻤﻭﺩ ﺍﻟﺜﺎﻨﻲ ﻓﻲ ﺠﺩﻭل‬
‫‪ Phone‬ﻭ ﺍﻟﺫﻱ ﻴﻤﺜل ﻜﺫﻟﻙ ﺭﻗﻡ ﺍﻟﻤﻭﻅﻑ‪.‬‬
‫‪ -٥‬ﻗﻤﻨﺎ ﺒﻌﺭﺽ ﻨﺘﻴﺠﺔ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻜﺎﻤﻠﺔ ﻋﻠﻰ ﺸﺒﻜﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫ﺍﻟﺒﺤﺙ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬

‫ﻴﻤﻜﻨﻙ ﺍﻟﺒﺤﺙ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﺨﻼل ﺘﻁﺒﻴﻕ ﺠﻤﻠﺔ ﺍﺴﺘﻔﺴﺎﺭ ﻋﻠﻰ ﺠﺩﻭل ﻤﻭﺠﻭﺩ ﻓﻲ‬
‫ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﺇﻥ ﺃﻓﻀل ﻁﺭﻴﻘﺔ ﻟﻠﻔﻬﻡ ﻫﻲ ﺍﻟﻤﺜﺎل ‪:‬‬
‫ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻨﻘﻭﻡ ﺒﺎﻟﺒﺤﺙ ﻋﻥ ﺍﻟﺼﻑ ﺍﻟﺫﻱ ﻴﺤﻭﻱ ﺍﺴﻡ ﺍﻟﻤﻭﻅﻑ ﻋﺒﺩﺍﷲ ﺜﻡ ﻋﺭﺽ‬
‫ﺭﻗﻡ ﺃﻭل ﻤﻭﻅﻑ ﻓﻲ ﻨﺘﻴﺠﺔ ﺍﻟﺒﺤﺙ‪:‬‬
‫= ‪Dim SearchRow() As DataRow‬‬
‫)"'ﻋﺒﺪاﷲ'=‪Myds.Tables("Person").Select("name‬‬
‫))‪MessageBox.Show(SearchRow(0).Item(0‬‬
‫ﻤﺎﺫﺍ ﻟﻭ ﺃﺭﺩﺕ ﺃﻥ ﺘﺭﺘﺏ ﻨﺘﻴﺠﺔ ﺍﻟﺒﺤﺙ ﺤﺴﺏ ﺤﻘل ﻤﺎ ﺘﺼﺎﻋﺩﻴﺎ ﺃﻭ ﺘﻨﺎﺯﻟﻴﺎ ؟‬
‫ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻨﻘﻭﻡ ﺒﺎﻟﺒﺤﺙ ﻋﻥ ﺍﻟﺼﻑ ﺍﻟﺫﻱ ﻴﺤﻭﻱ ﺍﺴﻡ ﺍﻟﻤﻭﻅﻑ ﻋﺒﺩﺍﷲ ﺜﻡ ﺘﺭﺘﻴﺏ‬
‫ﻨﺘﻴﺠﺔ ﺍﻟﺒﺤﺙ ﺤﺴﺏ ﺍﻟﺭﻗﻡ ﻤﻥ ﺍﻷﻋﻠﻰ ﺇﻟﻰ ﺍﻷﺩﻨﻰ ‪:‬‬
‫= ‪Dim SearchRow() As DataRow‬‬
‫)"‪'", "id DESC‬ﻋﺒﺪاﷲ'=‪Myds.Tables("Person").Select("name‬‬
‫))‪MessageBox.Show(SearchRow(0).Item(0‬‬
‫ﻻﺤﻅ ﺃﻨﻨﺎ ﺃﻀﻔﻨﺎ ﻋﺎﻤﻼ ﺜﺎﻨﻴﺎ ﻟﺩﺍﻟﺔ ﺍﻟﺒﺤﺙ ﻭﻫﻭ ﻤﺎ ﻨﺭﻴﺩ ﺃﻥ ﻨﺭﺘﺏ ﺍﻟﻨﺘﻴﺠﺔ ﺒﻨﺎﺀ ﻋﻠﻴﻪ ﻭﻫﻭ ﺭﻗﻡ‬
‫ﺍﻟﻤﻭﻅﻑ ﺜﻡ ﺃﺘﺒﻌﻨﺎﻩ ﺒﺨﻴﺎﺭ ﺍﻟﺘﺭﺘﻴﺏ ‪ DESC‬ﻭﻫﻭ ﻤﺎ ﻴﺭﺘﺏ ﺍﻟﻨﺘﻴﺠﺔ ﻤﻥ ﺍﻷﻋﻠﻰ ﺇﻟﻰ ﺍﻷﺩﻨﻰ‬
‫ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﺴﺘﻌﺭﻀﺎﺕ‬
‫ﺘﺘﻌﺩﺩ ﺍﺴﺘﺨﺩﺍﻤﺎﺕ ﺍﻟﻤﺴﺘﻌﺭﻀﺎﺕ ﻟﻜﻥ ﺃﺤﺩ ﺍﺴﺘﺨﺩﺍﻤﺎﺘﻬﺎ ﺍﻟﺸﺎﺌﻌﺔ ﻫﻲ ﺘﺭﺸﻴﺢ ﻋﺭﺽ ﺍﻟﺼﻔﻭﻑ ﻟﺫﻟﻙ‬
‫ﺘﻌﺘﺒﺭ ﺍﻟﻤﺴﺘﻌﺭﻀﺎﺕ ﺃﺤﺩ ﻁﺭﻕ ﺍﻟﺒﺤﺙ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪174‬‬
‫ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﺴﻨﻘﻭﻡ ﺒﺈﻨﺸﺎﺀ ﻤﺴﺘﻌﺭﺽ ﻭﻤﻥ ﺜﻡ ﺍﻟﺒﺤﺙ ﻓﻴﻪ ﻭﺘﺭﺘﻴﺏ ﺍﻟﺼﻔﻭﻑ ﺍﻟﻨﺎﺘﺠﺔ‬
‫ﻤﻥ ﻋﻤﻠﻴﺔ ﺍﻟﺒﺤﺙ ‪:‬‬
‫))"‪Dim DV As New DataView(Myds.Tables("Person‬‬
‫"'ﻋﺒﺪاﷲ'=‪DV.RowFilter = "name‬‬
‫"‪DV.Sort = "ename‬‬
‫ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﻗﻤﻨﺎ ﺒﺈﻨﺸﺎﺀ ﻤﺴﺘﻌﺭﺽ ﻟﻠﺼﻔﻭﻑ ﺍﻟﺘﻲ ﺘﺤﺘﻭﻱ ﺍﺴﻡ ﻋﺒﺩﺍﷲ ﺜﻡ ﺭﺘﺒﻨﺎ ﺍﻟﺼﻔﻭﻑ ﻓﻲ‬
‫ﺍﻟﻤﺴﺘﻌﺭﺽ ﺒﻨﺎﺀ ﻋﻠﻰ ﺍﻻﺴﻡ ﺍﻷﺨﻴﺭ‪.‬‬
‫ﺒﺭﻨﺎﻤﺞ ﺍﻟﺒﺤﺙ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬

‫ﺴﻭﻑ ﻨﺒﻨﻲ ﺒﺭﻨﺎﻤﺠﺎ ﻴﻁﺒﻕ ﺍﻷﻓﻜﺎﺭ ﺍﻟﺴﺎﺒﻘﺔ‪ ،‬ﻓﻜﺭﺓ ﻫﺫﺍ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻫﻭ ﺃﻥ ﻴﻜﻭﻥ ﻫﻨﺎﻙ ﺯﺭﻱ ﺍﺨﺘﻴﺎﺭ‬
‫ﺃﺤﺩﻫﻤﺎ ﻟﻠﺒﺤﺙ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﻓﻲ ﺍﻟﺫﺍﻜﺭﺓ ﻭ ﺍﻟﺜﺎﻨﻲ ﻻﺴﺘﺭﺠﺎﻉ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﻗﻭﺍﻋﺩ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻤﻥ ﺜﻡ ﺍﻟﺒﺤﺙ ﻓﻴﻬﺎ‪ .‬ﺴﻨﻘﻭﻡ ﺒﻌﺭﺽ ﺍﻟﻨﺘﻴﺠﺔ ﻋﻠﻰ ﺸﺒﻜﺔ ﺒﻴﺎﻨﺎﺕ‪.‬‬
‫ﻗﻡ ﺒﺘﺼﻤﻴﻡ ﺍﻟﺸﺎﺸﺔ ﺤﺴﺏ ﺍﻟﺸﻜل ﻭ ﺤﺴﺏ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﺠﺩﻭل ‪:‬‬

‫‪cmdSearch‬‬ ‫‪Name‬‬ ‫‪Button1‬‬
‫‪175‬‬
‫ﺒﺤﺙ‬ Text
Label1 Name Label1
Text
btnNewData Name RadioButton1
‫ﺍﻟﺒﺤﺙ ﺒﻨﺴﺨﺔ ﻤﺤﺩﺜﺔ‬ Text
rdoDSSearch Name RadioButton1
‫ﺍﻟﺒﺤﺙ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ Text
DataGrid1 Name dataGrid
‫ﺍﻟﺒﺤﺙ ﻋﻥ ﺍﻟﻤﻭﻅﻔﻴﻥ‬ Text Form1
Yes RightToLeft
‫ﻗﻡ ﺒﺈﻀﺎﻓﺔ ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ‬

Public Class SearchProj
Inherits System.Windows.Forms.Form
Private Sub cmdSearch_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles cmdSearch.Click
Dim sql As String = "select id,name,ename from person"
"Data Source=C:\TelDir.mdb;Persist Security
Info=False"
If rdoNewData.Checked Then
Myds.Clear()
Dim daPerson As New OleDb.OleDbDataAdapter(sql, con)
End If
If Myds.Tables.Count = 0 Then Exit Sub
Dim DV As New DataView(Myds.Tables("Person"))
DV.RowFilter = "name Like '" & txtEmpName.Text & "*'"
DV.Sort = "ename"
DataGrid1.DataMember = ""
DataGrid1.DataSource = Nothing
DataGrid1.DataSource = DV
End Sub
End Class
: ‫ﺍﻟﺫﻱ ﻴﺨﺹ ﻤﻭﻀﻭﻋﻨﺎ ﻤﻥ ﻫﺫﺍ ﺍﻟﻜﻭﺩ ﻫﻭ ﺍﻟﻤﻭﺠﻭﺩ ﺒﺨﻁ ﻋﺭﻴﺽ‬

‫ ﻨﺘﺄﻜﺩ ﻤﻥ ﺃﻥ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺘﺤﻭﻱ ﻋﻠﻰ ﺠﺩﻭل ﻭﺍﺤﺩ ﻋﻠﻰ ﺍﻷﻗل‬-١
‫ ﻨﻌﺭﻑ ﺍﻟﻤﺴﺘﻌﺭﺽ ﻋﻠﻰ ﺃﻨﻪ ﻤﺴﺘﻌﺭﺽ ﻟﺠﺩﻭل ﺍﻷﺸﺨﺎﺹ‬-٢
176
‫‪ -٣‬ﻋﺭﻓﻨﺎ ﺍﻟﻤﺭﺸﺢ‪ ،‬ﻻﺤﻅ ﻭﺠﻭﺩ ﺍﻟﻨﺠﻤﺔ ﻭﻫﻭ ﻤﺎ ﻴﻌﻨﻲ ﺃﻨﻨﺎ ﻨﺭﻴﺩ ﺍﻟﺒﺤﺙ ﻋﻥ ﺃﻭل ﺠﺯﺀ ﻴﺩﺨﻠﻪ‬
‫ﺍﻟﻤﺴﺘﺨﺩﻡ ﺜﻡ ﻨﺤﻀﺭ ﻜل ﻤﺎ ﻴﻁﺎﺒﻕ ﻫﺫﺍ ﺍﻟﺠﺯﺀ ﺒﻐﺽ ﺍﻟﻨﻅﺭ ﻋﻥ ﺒﺎﻗﻲ ﺍﻻﺴﻡ‬
‫‪ -٤‬ﻗﻤﻨﺎ ﺒﺎﻟﺘﺭﺘﻴﺏ ﺤﺴﺏ ﺍﻻﺴﻡ ﺍﻷﺨﻴﺭ‬
‫‪ -٥‬ﻓﺭﻏﻨﺎ ﺸﺒﻜﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﺃﻱ ﺒﻴﺎﻨﺎﺕ‬
‫‪ -٦‬ﺃﻋﺩﻨﺎ ﻋﺭﺽ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻋﻠﻰ ﺸﺒﻜﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ ،‬ﺍﻨﻅﺭ ﺍﻟﺸﻜل ﺍﻟﻨﻬﺎﺌﻲ ﺒﻌﺩ ﺍﻟﺘﻨﻔﻴﺫ‬
‫‪177‬‬
‫ﺭﺒﻁ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪Data Binding‬‬

‫ﺘﺴﺘﻁﻴﻊ ﻤﻥ ﺨﻼل ﺘﻘﻨﻴﺔ ﺭﺒﻁ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺭﺒﻁ ﺃﺩﺍﺓ ﺒﺤﻘل ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻴﻘﻭﻡ ﻓﻴﻪ ﺍﻟﺤﻘل ﺒﻌﺭﺽ‬
‫ﺒﻴﺎﻨﺎﺕ ﺫﻟﻙ ﺍﻟﺤﻘل ﻭﻤﻥ ﺜﻡ ﺘﺴﺘﻁﻴﻊ ﺍﻟﺘﻨﻘل ﺒﻴﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻟﻰ ﺍﻷﻭل ﻭ ﺍﻷﺨﻴﺭ ﻭ ﺍﻟﺘﺎﻟﻲ ﻭ ﺍﻟﺴﺎﺒﻕ ﻭ ﻓﻲ‬
‫ﺤﺎﻟﺔ ﺘﻌﺩﻴل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻴﻤﻜﻨﻙ ﻋﻜﺱ ﻫﺫﻩ ﺍﻟﺘﻌﺩﻴﻼﺕ ﻋﻠﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻜل ﻫﺫﻩ ﺍﻟﻌﻤﻠﻴﺔ ﻻﺘﺤﺘﺎﺝ ﺇﻟﻰ‬
‫ﺠﻬﺩ ﻜﺒﻴﺭ ﺒل ﺒﻀﻌﺔ ﺃﺴﻁﺭ ﻤﻥ ﺍﻟﻜﻭﺩ ﻟﻠﺘﻡ ﻋﻤﻠﻴﺔ ﺍﻟﺭﺒﻁ ﻭ ﺍﻟﺘﻨﻘل ﺒﻴﻥ ﺍﻟﺴﺠﻼﺕ‪.‬‬
‫ﻤﺜﺎل ‪ :‬ﻓﻲ ﻫﺫﺍ ﺍﻟﻤﺜﺎل ﺴﻨﻘﻭﻡ ﺒﻌﺭﺽ ﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﻭﻅﻑ ﻤﻥ ﺨﻼل ﺭﺒﻁ ﺃﺩﺍﺓ ﻤﺭﺒﻊ ﺍﻟﻨﺹ‬
‫ﺒﺎﺴﻡ ﺍﻟﻤﻭﻅﻑ ﻭ ﺍﻟﺘﻨﻘل ﺇﻟﻰ ﺍﻟﻤﻭﻅﻔﻴﻥ‪ .‬ﺍﻨﻅﺭ ﺍﻟﺸﻜل ﻭ ﻗﻡ ﺒﺘﺼﻤﻴﻤﻪ ﺤﺴﺏ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫‪cmdNext‬‬ ‫‪Name‬‬ ‫‪Button1‬‬
‫ﺍﻟﺘﺎﻟﻲ‬ ‫‪Text‬‬
‫‪cmdPerv‬‬ ‫‪Name‬‬ ‫‪Button٢‬‬
‫ﺍﻟﺴﺎﺒﻕ‬ ‫‪Text‬‬
‫‪cmdFirst‬‬ ‫‪Name‬‬ ‫‪Button٣‬‬
‫ﺍﻷﻭل‬ ‫‪Text‬‬
‫‪cmdLast‬‬ ‫‪Name‬‬ ‫‪Button٤‬‬
‫ﺍﻷﺨﻴﺭ‬ ‫‪Text‬‬
‫‪btnFetch‬‬ ‫‪Name‬‬ ‫‪Button٥‬‬
‫ﺇﺤﻀﺎﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ ‫‪Text‬‬
‫‪Text‬‬
‫‪Label1‬‬ ‫‪Name‬‬ ‫‪Label٢‬‬
‫‪176‬‬
‫ﺍﺴﻡ ﺍﻟﻤﻭﻅﻑ‬ Text

lblCurrent Name Label٣
‫ﺭﻗﻡ ﺍﻟﺴﺠل‬ Text
ListBox1 Name ‫ﺃﺩﺍﺓ ﻋﻨﻭﺍﻥ‬
‫ﺘﻨﻔﻴﺫ ﺃﻤﺭ ﻴﺴﺘﺭﺠﻊ ﻋﺩﺓ ﺼﻔﻭﻑ‬ Text Form1
Yes RightToLeft
‫ ﻗﻡ ﺒﺘﻁﺒﻴﻕ ﺨﺎﺼﻴﺔ ﺘﺠﺯﻱﺀ ﺍﻟﺠﻤل ﺤﺘﻰ ﻴﺘﺴﻨﻰ ﻋﺭﺽ ﺍﻷﺴﻁﺭ ﺍﻟﻁﻭﻴﻠﺔ ﻓﻲ ﺃﺴﻁﺭ‬: ‫ﻤﻼﺤﻅﺔ‬
‫ﻤﻘﻁﻌﺔ ﻭﻤﻘﺭﻭﺀﺓ ﻜﻤﺎ ﻴﻠﻲ‬
Edit Î Advance Î Word Wrap
: ‫ﺴﻭﻑ ﻨﻌﺭﺽ ﺍﻟﻜﻭﺩ ﻜﺎﻤﻼ ﺜﻡ ﻨﻘﻭﻡ ﺒﺸﺭﺤﻪ‬

Public Class DataBinding
Dim WithEvents bmb As BindingManagerBase
Private Sub btnFetch_Click(ByVal sender As System.Object, ByVal e

As System.EventArgs) Handles btnFetch.Click
Dim sql As String
sql = "select id,name from person"
Try
End Try
txtEmpName.DataBindings.Add("Text", Myds, "Person.name")
bmb = Me.BindingContext(Myds, "Person")
bmb.Position = bmb.Count
bmb.Position = 0
End Sub
Private Sub btnNext_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btnNext.Click
bmb.Position += 1
End Sub
Private Sub cmdPrev_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles cmdPrev.Click
bmb.Position -= 1
End Sub
Private Sub cmdLast_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles cmdLast.Click
177
‫‪bmb.Position = bmb.Count - 1‬‬

‫‪End Sub‬‬
‫‪Private Sub cmdFirst_Click(ByVal sender As System.Object, ByVal e‬‬

‫‪As System.EventArgs) Handles cmdFirst.Click‬‬
‫‪bmb.Position = 0‬‬
‫‪End Sub‬‬
‫‪Private Sub bmb_PositionChanged(ByVal sender As Object, ByVal e As‬‬

‫‪System.EventArgs) Handles bmb.PositionChanged‬‬
‫‪lblCurrent.text = String.Format("{0} of {1}", bmb.Position + 1,‬‬
‫)‪bmb.Count‬‬
‫‪End Sub‬‬
‫‪End Class‬‬
‫ﻴﻤﻜﻨﻨﺎ ﺸﺭﺡ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﻤﻥ ﺨﻼل ﺍﻟﻨﻘﺎﻁ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫‪Dim WithEvents bmb As BindingManagerBase‬‬ ‫‪-١‬ﻋﺭﻓﻨﺎ ﻤﺘﻐﻴﺭ ﻋﻠﻰ ﻤﺴﺘﻭﻯ ﺍﻟﻨﻤﻭﺫﺝ‬
‫ﺒﻤﻜﻥ ﻭﺼﻑ ﻫﺫﺍ ﺍﻟﻤﺘﻐﻴﺭ ﺒﺄﻨﻪ ﺍﻟﻜﺎﺌﻥ ﺍﻟﺫﻱ ﻴﻘﻭﻡ ﺒﺘﻨﺴﻴﻕ ﺍﻟﻌﻼﻗﺔ ﺒﻴﻥ ﻜﺎﺌﻨﺎﺕ ﺍﻟﺭﺒﻁ ﻭ ﻤﺠﻤﻭﻋﺔ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻓﻌﻠﻰ ﺴﺒﻴل ﺍﻟﻤﺜﺎل ﻋﻨﺩ ﺍﻻﻨﺘﻘﺎل ﻤﻥ ﺴﺠل ﺇﻟﻰ ﺁﺨﺭ ﻓﺈﻥ ﻫﺫﺍ ﺍﻟﻜﺎﺌﻥ ﻴﻘﻭﻡ ﺒﺎﻋﻼﻡ ﻜﺎﺌﻨﺎﺕ‬
‫ﺍﻟﺭﺒﻁ ﺒﺄﻥ ﺭﻗﻡ ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ ﻗﺩ ﺘﻐﻴﺭ ﻭ ﺃﻨﻪ ﻴﺘﻭﺠﺏ ﺘﻐﻴﻴﺭ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﻌﺭﻭﻀﺔ ﻋﻠﻰ ﺍﻷﺩﻭﺍﺕ ﺇﻟﻰ‬
‫ﺍﻟﻘﻴﻤﺔ ﺍﻟﺠﺩﻴﺩﺓ ﺍﻟﺘﻲ ﺘﻡ ﺍﻹﻨﺘﻘﺎل ﺇﻟﻴﻬﺎ‪.‬‬
‫‪ -٢‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻨﻲ ﻗﻤﻨﺎ ﺒﺘﻌﺭﻴﻑ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﺴﺘﺤﻭﻱ ﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﻭﻅﻔﻴﻥ‪.‬‬
‫‪ -٣‬ﻓﻲ ﺤﺩﺙ ﺍﻟﻨﻘﺭ ﺍﻟﺨﺎﺹ ﺒﺯﺭ ﺍﻷﻤﺭ ‪ btnFetch‬ﻗﻤﻨﺎ ﺒﺈﺤﻀﺎﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﻭﻀﻌﻬﺎ ﻓﻲ‬
‫ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ‪ .‬ﺍﻟﺠﺩﻴﺩ ﻓﻲ ﺍﻟﻤﻭﻀﻭﻉ ﻫﻨﺎ ﻫﻭ ﺍﻟﺠﻤل ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫)"‪txtEmpName.DataBindings.Add("Text", Myds, "Person.name‬‬
‫)"‪bmb = Me.BindingContext(Myds, "Person‬‬
‫‪bmb.Position = bmb.Count‬‬
‫‪bmb.Position = 0‬‬
‫ﻓﻲ ﺍﻟﺠﻤﻠﺔ ﺍﻷﻭﻟﻰ ﻗﻤﻨﺎ ﺒﺭﺒﻁ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ‪ txtEmpName‬ﺒﺎﻟﺤﻘل ‪Person.name‬‬

‫ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ .Myds‬ﻻﺤﻅ ﺃﻨﻨﺎ ﻗﻤﻨﺎ ﺒﺭﺒﻁ ﺍﻟﺨﺎﺼﻴﺔ ‪ . Text‬ﻭ ﺍﻟﺨﺎﺼﻴﺔ‬
‫ﺍﻟﻤﺭﺒﻭﻁﺔ ﺘﻌﺘﻤﺩ ﻋﻠﻰ ﺍﻷﺩﺍﺓ ﻓﻤﺜﻼ ﻟﻭ ﻜﺎﻨﺕ ﺃﺩﺍﺓ ﻤﺭﺒﻁ ﺍﺨﺘﻴﺎﺭ ﺴﻭﻑ ﻨﻘﻭﻡ ﺒﺭﺒﻁ ﺍﻟﺨﺎﺼﻴﺔ‬
‫‪ . Checked‬ﻓﻲ ﺍﻟﺠﻤﻠﺔ ﺍﻟﺜﺎﻨﻴﺔ ﻨﻘﻭﻡ ﺒﺘﺤﺩﻴﺩ ﺍﻁﺎﺭ ﺍﻟﺭﺒﻁ ﻷﻥ ﺍﻟﻨﻤﻭﺫﺝ ﻗﺩ ﻴﺤﻭﻱ ﺃﻜﺜﺭ ﻤﻥ ﺍﻁﺎﺭ‬
‫ﻭﺍﺤﺩ ﻓﻌﻠﻰ ﺴﺒﻴل ﺍﻟﻤﺜﺎل ﻗﺩ ﺘﻘﻭﻡ ﺒﺭﺒﻁ ﺒﻌﺽ ﺍﻷﺩﻭﺍﺕ ﺒﺠﺩﻭل ﺍﻟﻤﻭﻅﻔﻴﻥ ﻭ ﺒﻌﻀﻬﺎ ﺒﺠﺩﻭل ﺃﺭﻗﺎﻡ‬
‫ﺍﻟﻬﺎﺘﻑ‪ .‬ﺃﻤﺎ ﻓﻲ ﺍﻟﺴﻁﺭﻴﻥ ﺍﻟﺜﺎﻟﺙ ﻭ ﺍﻟﺭﺍﺒﻊ ﻓﻨﺤﻥ ﻨﻘﻭﻡ ﺒﻌﻤﻠﻴﺔ ﺍﻨﻌﺎﺵ ﻷﺯﺭﺍﺭ ﺍﻷﻤﺭ‪.‬‬
‫‪ -٤‬ﻓﻲ ﺍﻷﺤﺩﺍﺙ ﺍﻟﺨﺎﺼﺔ ﺒﺎﻟﺘﻨﻘل ﺒﻴﻥ ﺍﻟﺴﺠﻼﺕ ﺘﻼﺤﻅ ﺃﻨﻨﺎ ﻨﻘﻭﻡ ﺒﺎﻟﺘﻨﻘل ﺒﻴﻥ ﺍﻟﺴﺠﻼﺕ ﻤﻥ‬
‫ﺨﻼل ﺨﺎﺼﻴﺔ ‪.Postion‬‬
‫‪178‬‬
‫‪ -٥‬ﺍﻟﺤﺩﺙ ‪ bmb_PositionChanged‬ﻴﺘﻡ ﺘﻨﻔﻴﺫﻩ ﻜﻠﻤﺎ ﺘﻐﻴﻴﺭ ﻤﻭﻗﻊ ﺍﻟﺴﺠﻼﺕ ﻓﻨﻘﻭﻡ‬

‫ﺒﻬﺫﻩ ﺍﻟﺤﺎﻟﺔ ﺒﻌﺭﺽ ﺭﻗﻡ ﺍﻟﺴﺠل ﺍﻟﺤﺎﻟﻲ ﻭ ﺭﻗﻡ ﻤﺠﻤﻭﻉ ﺍﻟﺴﺠﻼﺕ‪.‬‬
‫‪ -٦‬ﻗﻡ ﺒﺘﺸﻐﻴل ﺍﻟﺒﺭﻨﺎﻤﺞ ﻟﻴﻅﻬﺭ ﻟﻙ ﺍﻟﺸﻜل‬
‫ﺭﺒﻁ ﺒﻴﺎﻨﺎﺕ ﺭﺃﺱ ﺒﺘﻔﺎﺼﻴل‬

‫ﺍﻨﺸﺎﺀ ﻨﻤﻭﺫﺝ ﻴﺭﺒﻁ ﺒﻴﺎﻨﺎﺕ ﺭﺌﻴﺴﻴﺔ ﺒﺒﻴﺎﻨﺎﺕ ﻓﺭﻋﻴﺔ ﻴﻌﺘﺒﺭ ﺘﺤﺼﻴل ﺤﺎﺼل ﺒﻔﻀل ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﻘﻭﻴﺔ‬
‫ﺒﺭﺒﻁ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻤﺎﻋﻠﻴﻙ ﺇﻻ ﺃﻥ ﺘﻀﻴﻑ ﺸﺒﻜﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﺍﻟﺘﻲ ﺴﺘﻅﻬﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻔﺭﻋﻴﺔ‪ ،‬ﻓﻌﻠﻰ ﺴﺒﻴل‬
‫ﺍﻟﻤﺜﺎل ﻤﺎﺫﺍ ﺍﻭ ﺃﺭﺩﺕ ﺃﻥ ﺘﻨﺘﻘل ﻤﻥ ﻤﻭﻅﻑ ﺇﻟﻰ ﺁﺨﺭ ﻭ ﺒﻤﺠﺭﺩ ﺍﻨﺘﻘﺎﻟﻙ ﻴﺘﻡ ﻋﺭﺽ ﺃﺭﻗﺎﻡ ﻫﺎﺘﻔﻪ ﻓﻲ‬
‫ﺸﺒﻜﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫ﻗﻡ ﺒﺘﺼﻤﻴﻡ ﺍﻟﺸﻜل ﺍﻟﺘﺎﻟﻲ ﺤﺴﺏ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﻤﻭﻀﺤﺔ ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﻤﻊ ﺇﻀﺎﻓﺔ‬
‫ﺸﺒﻜﺔ ﺒﻴﺎﻨﺎﺕ ﻜﻤﺎ ﻴﻅﻬﺭ ﻟﻙ ‪:‬‬
‫ﻓﻲ ﺍﻟﺤﻘﻴﻘﺔ ﺍﻟﻜﻭﺩ ﻓﻲ ﻫﺫﺍ ﺍﻟﻤﺜﺎل ﻫﻭ ﻨﻔﺱ ﺍﻟﻜﻭﺩ ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﻤﻊ ﺯﻴﺎﺩﺓ ﻻ ﺘﺫﻜﺭ‪ ،‬ﺴﻭﻑ ﻨﻌﺭﺽ‬
‫ﺍﻟﻜﻭﺩ ﺍﻵﻥ ﻭﺴﻭﻑ ﻨﺠﻌل ﺍﻟﺯﻴﺎﺩﺓ ﺒﺨﻁ ﻋﺭﻴﺽ ﺤﺘﻰ ﺘﻼﺤﻀﻬﺎ‪.‬‬
‫‪179‬‬

Dim sql As String
sql = "select id,name from person"
Try
Dim daPhone As New OleDb.OleDbDataAdapter("select & _
ID,Num,person from Phone", con)
daPhone.Fill(Myds, "Phone")
Myds.Relations.Add("PersonPhone",Myds.Tables("Person").Columns(0), & _
Myds.Tables("Phone").Columns(2), True)
End Try
Myds.WriteXml("da.xml")
txtEmpName.DataBindings.Add("Text", Myds, "Person.name")
DataGrid1.DataSource = Myds
DataGrid1.DataMember = "Person.PersonPhone"
bmb = Me.BindingContext(Myds, "Person")
bmb.Position = bmb.Count
bmb.Position = 0
: ‫ﺍﻹﻀﺎﻓﺎﺕ ﻫﻲ ﻜﻤﺎ ﻴﻠﻲ‬

.‫ ﻋﺭﻓﻨﺎ ﻤﻬﻲﺀ ﺒﻴﺎﻨﺎﺕ ﻹﺤﻀﺎﺭ ﺃﺭﻗﺎﻡ ﺍﻟﻬﺎﺘﻑ‬-١
.Phone ‫ ﻭ ﺍﺴﻤﻴﻨﺎ ﺍﻟﺠﺩﻭل‬Myds ‫ ﻗﻤﻨﺎ ﺒﺘﻌﺒﺌﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬-٢
‫ ﺒﺭﻗﻡ‬Person ‫ ﻗﻤﻨﺎ ﺒﺈﻨﺸﺎﺀ ﻋﻼﻗﺔ ﺒﻴﻥ ﺍﻟﺠﺩﻭﻟﻴﻥ ﻭ ﺫﻟﻙ ﺒﺭﺒﻁ ﺭﻗﻡ ﺍﻟﻤﻭﻅﻑ ﻓﻲ ﺍﻟﺠﺩﻭل‬-٣
PersonPhone ‫ ﻭ ﺍﺴﻤﻴﻨﺎ ﺍﻟﻌﻼﻗﺔ‬Phone ‫ﺍﻟﻤﻭﻅﻑ ﻓﻲ ﺍﻟﺠﺩﻭل‬
‫ ﻗﻤﻨﺎ ﺒﻌﺭﺽ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻋﻠﻰ ﺸﺒﻜﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﺫﻟﻙ ﺒﺘﻌﻴﻴﻥ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻟﻰ ﺸﺒﻜﺔ‬-٤
‫ ﻗﻴﻤﺔ ﺘﻤﺜل ﺍﺴﻡ ﺍﻟﻌﻼﻗﺔ ﺍﻟﺘﻲ‬datamember ‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻊ ﻤﻼﺤﻅﺔ ﺃﻨﻨﺎ ﺍﺴﻨﺩﻨﺎ ﺇﻟﻰ ﺍﻟﺨﺎﺼﻴﺔ‬
‫ ﻻﺤﻅ ﺃﻨﻨﺎ ﺍﺒﺘﺩﺃﻨﺎ ﺒﺎﺴﻡ ﺍﻟﺠﺩﻭل‬Person.PersonPhone ‫ﺃﻨﺸﺄﻨﻬﺎ ﺒﻴﻥ ﺍﻟﺠﺩﻭﻟﻴﻥ ﻭﻫﻲ‬
‫ﺍﻟﺭﺌﻴﺴﻲ ﺜﻡ ﺍﺴﻡ ﺍﻟﻌﻼﻗﺔ‬
‫ ﻗﻡ ﺒﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻟﻴﻅﻬﺭ ﻟﻙ ﺍﻟﺸﻜل‬-٥
180
181
‫ﺘﺤﺩﻴﺙ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﺍﻟﺒﻴﺌﺔ ﺍﻟﻤﻨﻔﺼﻠﺔ‬

‫ﻤﺭ ﺒﻙ ﻓﻲ ﺍﻟﺒﺎﺏ ﺍﻟﺨﺎﺹ ﺒﺎﻟﺒﻴﺌﺔ ﺍﻟﻤﻨﻔﺼﻠﺔ ﺒﺄﻥ ﺘﻌﺭﻴﻑ ﺍﻟﺒﻴﺌﺔ ﺍﻟﻤﻨﻔﺼﻠﺔ ﻫﻲ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ ﻴﺘﻡ‬
‫ﻨﺴﺨﻬﺎ ﻤﻥ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺜﻡ ﻗﻁﻊ ﺍﻻﺘﺼﺎل ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﺇﺠﺭﺍﺀ ﺍﻟﻌﻤﻠﻴﺎﺕ ﻋﻠﻰ ﻫﺫﻩ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ﺇﻀﺎﻓﺔ ﻭ ﺤﺫﻓﺎ ﻭ ﺘﻌﺩﻴﻼ ﺜﻡ ﺇﺭﺠﺎﻉ ﻜل ﻤﺎ ﺘﻡ ﻤﻥ ﻋﻤﻠﻴﺎﺕ ﺇﻟﻰ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻭ ﻜﻤﺎ ﻤﺭ ﺒﻙ ﺴﺎﺒﻘﺎ‬
‫ﻓﺈﻥ ﻤﻥ ﻋﻴﻭﺏ ﻫﺫﻩ ﺍﻟﺒﻴﺌﺔ ﺇﻤﻜﺎﻨﻴﺔ ﺤﺩﻭﺙ ﺘﻀﺎﺭﺏ ﻓﻲ ﺘﻌﺩﻴل ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻫﻭ ﻤﺎﻴﺘﻁﻠﺏ ﺤل ﻫﺫﻩ‬
‫ﺍﻟﻤﺸﺎﻜل‪ .‬ﻋﺭﻓﺕ ﻓﻲ ﺍﻟﻔﺼل ﺍﻟﺨﺎﺹ ﺒﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻜﻴﻔﻴﺔ ﺍﺴﺘﺭﺠﺎﻉ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ ﻭ ﻋﺭﻀﻬﺎ‬
‫ﻋﻠﻰ ﻨﻤﻭﺫﺝ‪ ،‬ﻤﺎ ﺘﺒﻘﻰ ﻫﻭ ﺍﻟﺠﺯﺀ ﺍﻟﺨﺎﺹ ﺒﺘﻌﺩﻴل ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﻤﻥ ﺜﻡ ﺍﺭﺠﺎﻉ ﻫﺫﻩ ﺍﻟﺘﻌﺩﻴﻼﺕ‬
‫ﺇﻟﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﺤل ﺃﻱ ﻤﺸﻜﻠﺔ ﺘﻨﺘﺞ ﻋﻨﺩ ﺘﻌﺩﻴل ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫ﻗﺒﻭل ﻭ ﺭﻓﺽ ﺍﻟﺘﻌﺩﻴﻼﺕ‬

‫ﻨﻅﺭﺍ ﻷﻥ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻴﻌﺘﺒﺭ ﻤﺨﺯﻥ ﺒﻴﺎﻨﺎﺕ ﻤﻭﺠﻭﺩ ﻓﻲ ﺫﺍﻜﺭﺓ ﺍﻟﻤﺴﺘﻔﻴﺩ ﻤﻥ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ ،‬ﺃﻱ ﺃﻥ‬
‫ﻫﺫﻩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻔﺼﻭﻟﺔ ﻋﻥ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﺈﻥ ﻜل ﺘﻌﺩﻴل ﻴﺘﻡ ﻋﻠﻰ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻻ ﻴﺘﻡ ﻋﻜﺴﻪ‬
‫ﻤﺒﺎﺸﺭﺓ ﻋﻠﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻤﻥ ﻫﻨﺎ ﻅﻬﺭ ﺃﻥ ﻫﻨﺎﻙ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻷﺨﻁﺎﺀ ﺴﻭﻑ ﺘﻅﻬﺭ ﻋﻨﺩ‬
‫ﻤﺤﺎﻭﻟﺔ ﺘﺤﺩﻴﺙ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻫﻭ ﻤﺎ ﻴﺘﻁﻠﺏ ﺍﻟﺒﺤﺙ ﻋﻥ ﻫﺫﻩ ﺍﻷﺨﻁﺎﺀ ﻭﻋﺭﻀﻬﺎ ﻟﻠﻤﺴﺘﺨﺩﻡ ﻟﻜﻲ‬
‫ﻴﺘﻡ ﺘﻌﺩﻴﻠﻬﺎ‪ .‬ﻤﻥ ﺃﻤﺜﻠﺔ ﻫﺫﻩ ﺍﻷﺨﻁﺎﺀ ‪:‬‬
‫‪ -١‬ﻤﺨﺎﻟﻔﺔ ﻗﻭﺍﻋﺩ ﺍﻟﻌﻤل ﺃﻭ ﺍﻟﻘﻴﻭﺩ ﺍﻟﻤﻔﺭﻭﻀﺔ ﻋﻠﻰ ﺍﻟﺤﻘﻭل ‪ :‬ﻫﺫﻩ ﺍﻟﻘﻭﺍﻋﺩ ﺃﻭ ﺍﻟﻘﻴﻭﺩ ﻻ ﺘﻨﺘﻘل‬
‫ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒل ﺘﻅل ﻤﻭﺠﻭﺩﺓ ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ ،‬ﻤﺎﺫﺍ ﻟﻭ ﻜﺎﻥ ﻫﻨﺎﻙ ﻗﻴﺩ ﻋﻠﻰ ﺃﺤﺩ‬
‫ﺍﻟﺤﻘﻭل ﻴﻤﻨﻊ ﺃﻥ ﻴﺘﻜﺭﺭ ﻫﺫﺍ ﺍﻟﺤﻘل ﺃﻭ ﻴﻔﺭﺽ ﻗﻴﻤﺔ ﻤﻭﺠﺒﺔ ﻟﻬﺫﺍ ﺍﻟﺤﻘل‪ ،‬ﺇﻥ ﻤﺤﺎﻭﻟﺔ ﺘﻌﺩﻴل‬
‫ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ ﺴﻭﻑ ﻴﺴﺒﺏ ﻤﺸﻜﻠﺔ ﻴﺠﺏ ﻋﺭﻀﻬﺎ ﻋﻠﻰ ﺍﻟﻤﺴﺘﻔﻴﺩ‪.‬‬
‫‪ -٢‬ﻤﺎﺫﺍ ﻟﻭ ﺃﺭﺍﺩ ﻤﺴﺘﻔﻴﺩ ﺘﻌﺩﻴل ﻗﻴﻤﺔ ﻟﺤﻘل ﻗﺎﻡ ﺒﺤﺫﻓﻬﺎ ﻤﺴﺘﻔﻴﺩ ﺁﺨﺭ‪.‬‬
‫ﺇﻀﺎﻓﺔ ﺼﻑ ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ‬

‫ﺴﻭﻑ ﻨﺭﻯ ﻜﻴﻔﻴﺔ ﺇﻀﺎﻓﺔ ﺼﻑ ﺇﻟﻰ ﺠﺩﻭل ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ ،‬ﻤﺎ ﺃﺤﺏ ﺃﻥ ﺃﻨﺒﻪ ﻋﻠﻴﻪ ﻫﻭ ﺃﻥ‬
‫ﺇﻀﺎﻓﺔ ﺼﻑ ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ ﻻ ﻴﻌﻨﻲ ﺇﻀﺎﻓﺘﻪ ﺇﻟﻰ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒل ﻴﻌﻨﻲ ﺃﻨﻙ ﺃﻀﻔﺘﻪ ﺇﻟﻰ‬
‫ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﺫﺍﻜﺭﺓ ﻭ ﺘﻡ ﻭﻀﻊ ﻋﻼﻤﺔ ﻋﻠﻴﻪ ﻟﺘﻤﻴﺯﻩ ﺒﺄﻨﻪ ﺼﻑ ﺘﻡ ﺇﻀﺎﻓﺘﻪ‪ ،‬ﻓﻠﻭ‬
‫ﺘﻭﻗﻑ ﺍﻟﺠﻬﺎﺯ ﻋﻥ ﺍﻟﻌﻤل ﻟﺴﺒﺏ ﻤﺎ ﻭ ﻀﺎﻉ ﻤﺎ ﻓﻲ ﺍﻟﺫﺍﻜﺭﺓ ﻓﺈﻥ ﻜل ﺍﻹﻀﺎﻓﺎﺕ ﺍﻟﺘﻲ ﻗﻤﺕ ﺒﻬﺎ ﻗﺩ‬
‫ﺫﻫﺒﺕ ﺃﺩﺭﺍﺝ ﺍﻟﺭﻴﺢ ﻷﻨﻪ ﻟﻡ ﻴﺘﻡ ﺘﺤﺩﻴﺙ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﻬﺎ‪.‬‬
‫‪182‬‬
‫ﺘﺘﻡ ﺇﻀﺎﻓﺔ ﺼﻑ ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ ﻜﻤﺎ ﻴﻠﻲ ‪:‬‬

‫‪ -١‬ﺍﺴﺘﺨﺩﻡ ﺍﻟﻁﺭﻴﻘﺔ ‪ NewRow‬ﻭ ﺍﻟﺘﻲ ﺘﻨﺘﻤﻲ ﺇﻟﻰ ﻜﺎﺌﻥ ﺍﻟﺠﺩﻭل ﻹﻨﺸﺎﺀ ﺼﻑ ﺠﺩﻴﺩ‬
‫‪ -٢‬ﻋﻴﻥ ﻗﻴﻡ ﻜل ﺤﻘل ﻤﻥ ﺤﻘﻭل ﻓﻲ ﻫﺫﺍ ﺍﻟﺼﻑ‬
‫‪ -٣‬ﻗﻡ ﺒﺘﻤﺭﻴﺭ ﺍﻟﺼﻑ ﻭ ﺇﻀﺎﻓﺘﻪ ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ ﺼﻔﻭﻑ ﺍﻟﺠﺩﻭل‬
‫ﻗﺒل ﺇﻀﺎﻓﺔ ﺃﻱ ﻗﻴﻤﺔ ﺇﻟﻰ ﺍﻟﺠﺩﻭل ﻴﺘﻭﺠﺏ ﻋﻠﻴﻙ ﺍﻟﺘﺄﻜﺩ ﻤﻥ ﻋﺩﻡ ﻤﺨﺎﻟﻔﺘﻬﺎ ﻟﻘﻭﺍﻋﺩ ﺍﻟﻌﻤل‪ ،‬ﻓﻌﻠﻰ ﺴﺒﻴل‬
‫ﺍﻟﻤﺜﺎل ﺇﺫﺍ ﻜﺎﻥ ﺍﻟﻤﺩﺨل ﻻ ﻴﻘﺒل ﺍﻟﻘﻴﻡ ﺍﻟﺴﺎﻟﺒﺔ ﺘﺄﻜﺩ ﻤﻥ ﺃﻥ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﺩﺨﻠﺔ ﻤﻭﺠﺒﺔ‪.‬‬
‫ﺃﻤﺜﻠﺔ ﻤﺘﻨﻭﻋﺔ ﻹﻀﺎﻓﺔ ﺼﻔﻭﻑ ‪:‬‬
‫ﻟﺘﻁﺒﻴﻕ ﻜل ﺍﻟﺨﻁﻭﺍﺕ ﺍﻟﺜﻼﺙ ﺍﻟﺴﺎﺒﻘﺔ ﺇﻟﻴﻙ ﻫﺫﺍ ﺍﻟﻤﺜﺎل ‪:‬‬

‫)‪Dim dtPerson As DataTable = Myds.Tables(0‬‬
‫)(‪Dim dr As DataRow = dtPerson.NewRow‬‬
‫"ﻋﺒﺪاﻟﻠـﻪ" = )"‪dr("name‬‬
‫"‪dr("ename") = "Abduallah‬‬
‫)‪dtPerson.Rows.Add(dr‬‬
‫)‪MessageBox.Show(Myds.Tables(0).Rows.Count‬‬
‫ﻴﻤﻜﻥ ﺸﺭﺡ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﺒﺎﻟﺨﻁﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫‪ -١‬ﺃﻨﺸﺄﻨﺎ ﺼﻑ ﺠﺩﻴﺩ ﻤﻥ ﻨﻭﻉ ﺼﻑ ﺒﻴﺎﻨﺎﺕ ﻭ ﻋﻴﻨﺎ ﻟﻪ ﻗﻴﻤﺔ ﺼﻑ ﻓﺎﺭﻍ ﻤﻥ ﺠﺩﻭل ﺍﻷﺸﺨﺎﺹ‪.‬‬
‫‪ -٢‬ﻋﻴﻨﺎ ﻗﻴﻡ ﻜل ﺤﻘل ﻓﻲ ﻫﺫﺍ ﺍﻟﺼﻑ‪.‬‬
‫‪ -٣‬ﺃﻀﻔﻨﺎ ﺍﻟﺼﻑ ﻜﺎﻤﻼ ﺇﻟﻰ ﺠﺩﻭل ﺍﻷﺸﺨﺎﺹ‬
‫‪ -٤‬ﺃﻅﻬﺭﻨﺎ ﺭﺴﺎﻟﺔ ﻗﺒل ﻋﻤﻠﻴﺔ ﺍﻹﻀﺎﻓﺔ ﻭ ﺒﻌﺩﻫﺎ ﻟﺘﻅﻬﺭ ﻋﺩﺩ ﺍﻟﺼﻔﻭﻑ ﻓﻲ ﺍﻟﺠﺩﻭل‬
‫ﻻﺤﻅ ﺃﻨﻨﺎ ﻟﻡ ﻨﻌﻴﻥ ﻗﻴﻤﺔ ﻟﺭﻗﻡ ﺍﻟﻤﻭﻅﻑ ﻟﻜﻭﻨﻪ ﺭﻗﻤﺎ ﺘﺴﻠﺴﻠﻴﺎ ﻴﺘﻡ ﺇﻨﺸﺎﺌﻪ ﺒﻭﺍﺴﻁﺔ ﻗﻭﺍﻋﺩ‬
‫ﻴﻜﻔﻴﻙ ﻫﺫﻩ ﺍﻟﺼﻴﻐﺔ ﻭ ﺍﻟﺘﻲ ﺴﻭﻑ ﺘﻌﻤل ﺒﻨﻔﺱ ﺍﻟﻁﺭﻴﻘﺔ ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ‪:‬‬
‫)}"‪","Abduallah‬ﻋﺒﺩﺍﻟﻠـﻪ" ‪Myds.Tables("Person").Rows.Add(New Object() {Nothing,‬‬
‫ﻗﻤﻨﺎ ﺒﻭﻀﻊ ﻗﻴﻤﺔ ‪ Nothing‬ﻟﺭﻗﻡ ﺍﻟﻤﻭﻅﻑ ﺤﺘﻰ ﻴﺘﻡ ﺘﻌﻴﻴﻨﻪ ﻤﻥ ﻗﺒل ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪183‬‬
‫ﺘﺤﺩﻴﺙ ﺼﻔﻭﻑ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬

‫ﻜﻤﺎ ﻤﺭ ﺒﻙ ﻓﻲ ﺇﻀﺎﻓﺔ ﺼﻔﻭﻑ ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﺈﻥ ﺍﻟﺼﻔﻭﻑ ﺍﻟﺘﻲ ﻴﺘﻡ ﺘﻌﺩﻴﻠﻬﺎ ﻫﻨﺎ ﻻ ﻴﺘﻡ‬
‫ﺘﻌﺩﻴﻠﻬﺎ ﻓﻲ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻨﻤﺎ ﻴﺘﻡ ﺘﻌﺩﻴﻠﻬﺎ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﺍﻟﺫﺍﻜﺭﺓ‪.‬‬
‫ﺇﻟﻴﻙ ﻫﺫﺍ ﺍﻟﻤﺜﺎل ﺍﻟﺫﻱ ﺴﻨﻘﻭﻡ ﻓﻴﻪ ﺒﺘﻌﺩﻴل ﺍﺴﻡ ﺍﻟﺸﺨﺹ ﺍﻟﻌﺭﺒﻲ ﻭ ﺍﺴﻤﻪ ﺍﻹﻨﺠﻠﻴﺯﻱ ﻟﻠﺼﻑ‬
‫ﺍﻷﺨﻴﺭ‪:‬‬
‫)‪Dim dr As DataRow = dtPerson.Rows(dtPerson.Rows.Count - 1‬‬
‫ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﺴﻨﻘﻭﻡ ﺒﺘﻌﺩﻴل ﺍﻻﺴﻡ ﺍﻹﻨﺠﻠﻴﺯﻱ ﻟﻜل ﺍﻷﺸﺨﺎﺹ ﻟﻜﻲ ﺘﺼﺒﺢ ﻗﻴﻤﻪ ﻓﺎﺭﻏﺔ‬
‫‪Dim dr As DataRow‬‬
‫‪For Each dr In dtPerson.Rows‬‬
‫"" = )"‪dr("ename‬‬
‫‪Next‬‬
‫ﺤﺫﻑ ﺍﻟﺼﻔﻭﻑ ﻤﻥ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬

‫ﻴﻭﺠﺩ ﻁﺭﻴﻘﺘﺎﻥ ﻟﺤﺫﻑ ﺼﻑ ﻤﻥ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪:‬‬
‫‪ -١‬ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻁﺭﻴﻘﺔ ‪ Delete‬ﻭ ﺍﻟﺘﻲ ﺘﻌﺘﺒﺭ ﺃﺤﺩ ﻁﺭﻕ ﺍﻟﺼﻑ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ ،‬ﺍﻟﻤﺜﺎل‬
‫ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﻜﻴﻑ ﻴﺘﻡ ﺤﺫﻑ ﺼﻑ ﻤﻥ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ ‪:‬‬
‫)(‪Myds.Tables(0).Rows(1).Delete‬‬
‫ﺘﻘﻭﻡ ﺍﻟﻁﺭﻴﻘﺔ ‪ Delete‬ﺒﻭﻀﻊ ﻋﻼﻤﺔ ﻋﻠﻰ ﺍﻟﺼﻑ ﺘﺩل ﻋﻠﻰ ﺃﻨﻪ ﺘﻡ ﺤﺫﻓﻪ‪.‬‬
‫‪ -٢‬ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻁﺭﻴﻘﺔ ‪ Remove‬ﻭ ﺍﻟﺘﻲ ﺘﻘﻭﻡ ﺒﺈﻟﻐﺎﺀ ﻫﺫﺍ ﺍﻟﺼﻑ ﻤﻥ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ ،‬ﻜﻤﺎ‬
‫ﻴﻭﻀﺢ ﺫﻟﻙ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫)‪Dim dr As DataRow = Myds.Tables(0).Rows(1‬‬
‫)‪Myds.Tables(0).Rows.Remove(dr‬‬
‫ﺘﻡ ﺤﺫﻑ ﺍﻟﺼﻑ ﻤﻥ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﻜﻥ ﻟﻡ ﻴﺘﻡ ﺤﺫﻓﻪ ﻤﻥ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪184‬‬
‫ﻗﺒﻭل ﺃﻭ ﺭﻓﺽ ﺍﻟﺘﻌﺩﻴﻼﺕ‬

‫ﺴﺒﻕ ﻭ ﺃﻥ ﺒﻴﻨﺎ ﻟﻙ ﺃﻥ ﻜل ﻤﺎ ﺘﻘﻭﻡ ﺒﻪ ﻤﻥ ﻋﻤﻠﻴﺎﺕ ﻋﻠﻰ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻻ ﻴﺘﻡ ﻋﻜﺴﻪ ﻋﻠﻰ ﻗﻭﺍﻋﺩ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒل ﻴﺘﻡ ﻭﻀﻊ ﻋﻼﻤﺔ ﻋﻠﻰ ﺍﻟﺼﻑ ﺍﻟﻤﺘﺄﺜﺭ ﺒﺎﻟﻌﻤﻠﻴﺔ‪ ،‬ﻓﻠﻭ ﻗﻤﺕ ﺒﺈﻀﺎﻓﺔ ﺼﻑ ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﺴﻭﻑ ﻴﺘﻡ ﻭﻀﻊ ﻋﻼﻤﺔ ﻋﻠﻴﻪ ﺘﺩل ﻋﻠﻰ ﺃﻨﻪ ﺼﻑ ﺘﻡ ﺇﻀﺎﻓﺘﻪ ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ ،‬ﻭﻫﺫﺍ‬
‫ﺍﻟﻜﻼﻡ ﻴﻨﻁﺒﻕ ﻋﻠﻰ ﻜل ﺼﻑ ﺘﻘﻭﻡ ﺒﺤﺫﻓﻪ ﺃﻭ ﺘﻌﺩﻴﻠﻪ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻫﺫﻩ ﺍﻟﻌﻼﻤﺔ ﻴﺘﻡ ﻭﻀﻌﻬﺎ‬
‫ﻟﻜل ﺼﻑ ﻤﻥ ﺨﻼل ﺨﺎﺼﻴﺔ ‪ .Rowstate‬ﺘﻤﺜل ﻗﻴﻤﺔ ﻫﺫﻩ ﺍﻟﺨﺎﺼﻴﺔ ﺤﺎﻟﺔ ﺍﻟﺼﻑ‪ ،‬ﻭ ﺇﻟﻴﻙ ﺍﻟﺤﺎﻻﺕ‬
‫ﺍﻟﻤﺤﺘﻤﻠﺔ ﻟﻜل ﺼﻑ ‪:‬‬
‫ﺍﻟﻭﺼﻑ‬ ‫ﺍﻟﺤﺎﻟﺔ‬
‫ﺘﻤﺕ ﺇﻀﺎﻓﺔ ﻫﺫﺍ ﺍﻟﺼﻑ ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬ ‫‪Added‬‬
‫ﺘ ّﻡ ﺤﺫﻑ ﻫﺫﺍ ﺍﻟﺼﻑ ﻤﻥ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬ ‫‪Deleted‬‬
‫ﺘ ّﻡ ﺇﻨﺸﺎﺀ ﻫﺫﺍ ﺍﻟﺼﻑ ﻭﻟﻜﻨﹼﻪ ﻟﻡ ﻴﺤﻔﻅ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻟﻰ ﺍﻵﻥ‪.‬‬ ‫‪Detached‬‬
‫ﺘ ّﻡ ﺘﻌﺩﻴل ﻫﺫﺍ ﺍﻟﺼﻑ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬ ‫‪Modified‬‬
‫‪ Unchanged‬ﻟﻡ ﻴﺘ ّﻡ ﺘﻐﻴﻴﺭ ﻤﺤﺘﻭﻴﺎﺕ ﺍﻟﺼﻑ‪.‬‬
‫ﻤﻥ ﺍﻟﻤﻘﺩﻤﺔ ﺍﻟﺴﺎﺒﻘﺔ ﻨﺴﺘﻁﻴﻊ ﺍﺴﺘﻨﺘﺎﺝ ﺃﻨﻨﺎ ﻨﺴﺘﻁﻴﻊ ﺍﺴﺘﺨﻼﺹ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﻗﺎﻡ ﺍﻟﻤﺴﺘﻔﻴﺩ ﺒﺘﺤﺩﻴﺜﻬﺎ ﻓﻲ‬
‫ل ﺼﻔﻭﻑ ﺍﻟﻤﺠﻤﻭﻋﺔ ﺇﻟﻰ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ ،‬ﻴﻤﻜﻨﻙ ﺃﻥ ﺘﹸﺭﺴل ﻓﻘﻁ‬
‫ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﺒﺩﻻ ﻤﻥ ﺇﺭﺴﺎل ﻜ ّ‬
‫ﺍﻟﺼﻔﻭﻑ ﺍﻟﻤﻌﺩّﻟﺔ ﻭﺍﻟﻤﻀﺎﻓﺔ ﻭﺍﻟﻤﺤﺫﻭﻓﺔ ﺇﻟﻰ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻫﻭ ﻤﺎ ﻴﻭﻓﺭ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﻤﻭﺍﺭﺩ ﻟﺨﺎﺩﻡ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﻟﺸﺒﻜﺔ ﺍﻻﺘﺼﺎل‪.‬‬
‫ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﻜﻴﻑ ﻨﻌﺭﻑ ﺤﺎﻟﺔ ﺼﻑ ﻤﺎ ﻤﻥ ﺨﻼل ﺨﺎﺼﻴﺔ ‪:Rowstate‬‬

‫)(‪Dim dr As DataRow = dtPerson.NewRow‬‬
‫)‪MessageBox.Show(dr.RowState‬‬
‫)‪dtPerson.Rows.Add(dr‬‬
‫)‪MessageBox.Show(dr.RowState‬‬
‫ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﻗﻤﻨﺎ ﺒﻌﺭﺽ ﺤﺎﻟﺔ ﺍﻟﺼﻑ ﺒﻌﺩ ﺇﻨﺸﺎﺌﻪ ﻟﻜﻥ ﻗﺒل ﺤﻔﻅﻪ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﺜﻡ‬
‫ﻗﻤﻨﺎ ﺒﻌﺭﺽ ﺤﺎﻟﺘﻪ ﺒﻌﺩ ﺤﻔﻅﻪ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪185‬‬
‫ﺘﺤﺩﻴﺙ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‬

‫ﺴﻭﻑ ﻨﻘﻭﻡ ﺒﺎﺴﺘﻌﺭﺍﺽ ﺃﻜﺜﺭ ﻤﻥ ﻁﺭﻴﻘﺔ ﻟﺘﺤﺩﻴﺙ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﺘﻼﺤﻅ ﺍﻟﻔﺭﻕ ﺒﻴﻨﻬﺎ ﻓﻴﻤﺎ ﻴﺘﻌﻠﻕ‬
‫ﺒﺎﻷﺩﺍﺀ ﻭ ﺍﺴﺘﻬﻼﻙ ﻤﻭﺍﺭﺩ ﺍﻟﻨﻅﺎﻡ ﻴﻤﻜﻥ ﺍﻟﻘﻭل ﺒﺄﻥ ﻫﻨﺎﻙ ﻭﺴﻴﻠﺘﺎﻥ ﻟﺘﺤﺩﻴﺙ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪:‬‬
‫‪ -١‬ﺍﺭﺴﺎل ﻜل ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻟﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪ :‬ﻭﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﻏﻴﺭ ﻓﻌﺎﻟﺔ ﻭﺘﺴﺘﻬﻠﻙ‬
‫ﻤﻭﺍﺭﺩ ﻜﺒﻴﺭﺓ ﻤﻥ ﺍﻟﺸﺒﻜﺔ ﻭ ﺨﺎﺩﻡ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﻫﺫﻩ ﺍﻟﻔﻜﺭﺓ ‪:‬‬
‫ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﺇﺭﺴﺎل ﻜل ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻟﻰ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪:‬‬
‫)(‪Dim Myds As New DataSet‬‬
‫"‪Dim sql As String = "select id,name,ename from person‬‬
‫‪Try‬‬
‫)‪Dim daPerson As New OleDb.OleDbDataAdapter(sql, con‬‬
‫)"‪daPerson.Fill(Myds, "Person‬‬
‫‪Myds.Tables("Person").Rows.Add(New Object() {Nothing,‬‬
‫)}"‪", "Abdulallah‬ﻋﺒﺪاﷲ"‬
‫)‪Dim ComBuilder As New OleDb.OleDbCommandBuilder(daPerson‬‬
‫‪daPerson.InsertCommand = ComBuilder.GetInsertCommand‬‬
‫)"‪daPerson.Update(Myds, "Person‬‬
‫)‪MessageBox.Show(e1.Message‬‬
‫‪End Try‬‬

‫‪ -١‬ﻋﺭﻓﻨﺎ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ ﻭ ﺍﺘﺼﺎل ﺜﻡ ﺃﻋﻠﻨﺎ ﻋﻥ ﺍﻻﺴﺘﻌﻼﻡ ﺜﻡ ﻋﻴﻨﺎ ﻗﻴﻤﺔ ﻟﺴﻠﺴﻠﺔ ﺍﻻﺘﺼﺎل‪.‬‬
‫‪ -٢‬ﻋﺭﻓﻨﺎ ﻤﻬﻲﺀ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺜﻡ ﺍﺴﺘﺭﺠﻌﻨﺎ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﻋﺒﺌﻨﺎ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪ -٣‬ﺃﻀﻔﻨﺎ ﺼﻑ ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ ،‬ﺤﺘﻰ ﻫﺫﻩ ﺍﻟﻠﺤﻅﺔ ﻟﻡ ﻴﺘﻡ ﺘﺤﺩﻴﺙ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪ -٤‬ﻗﻤﻨﺎ ﺒﺘﻌﺭﻴﻑ ﺍﻷﻤﺭ ﺍﻟﺫﻱ ﺴﻴﻘﻭﻡ ﺒﺘﺤﺩﻴﺙ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ ،‬ﻨﻅﺭﺍ ﻷﻥ ﻤﻬﻲﺀ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻻ ﻴﻤﻜﻨﻪ‬
‫ﺃﻥ ﻴﺤﺩﺙ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻷﻨﻪ ﻻ ﻴﺤﻭﻱ ﺠﻤﻠﺔ ﺍﻹﻀﺎﻓﺔ ﺇﻟﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻘﺩ ﺃﻨﺸﺄﻨﺎ ﺠﻤﻠﺔ‬
‫ﺍﻹﻀﺎﻓﺔ ﺇﻟﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﻤﻬﻲﺀ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﺨﻼل ﻜﺎﺌﻥ ﺒﺎﻨﻲ ﺍﻷﻤﺭ‬
‫‪.CommandBuilder‬‬
‫‪ -٥‬ﺘﻡ ﺘﺤﺩﻴﺙ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﺨﻼل ﺍﻟﻁﺭﻴﻘﺔ ‪ Update‬ﻭﻫﻲ ﺃﺤﺩ ﻁﺭﻕ ﻤﻬﻲﺀ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪186‬‬
‫ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﺃﻀﻔﻨﺎ ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺼﻔﺎ ﻭﺍﺤﺩ ﻟﺫﻟﻙ ﻗﻤﻨﺎ ﺒﺎﺴﺘﺨﺩﺍﻡ ﻭﻅﻴﻔﺔ ﺍﻹﻀﺎﻓﺔ‬
‫ ﻋﻨﺩ ﺤﺫﻑ ﺃﻭ ﺘﺤﺩﻴﺙ ﺼﻔﻭﻑ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﺴﺘﺨﺩﻡ ﻭﻅﺎﺌﻑ ﺍﻟﺤﺫﻑ‬،‫ﺍﻟﺨﺎﺼﺔ ﺒﺒﺎﻨﻲ ﺍﻷﻤﺭ‬
‫ﻭﺍﻟﺘﺤﺩﻴﺙ ﻜﻤﺎ ﻴﻠﻲ‬
daPerson.DeleteCommand = ComBuilder.GetDeleteCommand
daPerson.UpdateCommand = ComBuilder.GetUpdateCommand
‫ ﺘﻌﺘﺒﺭ ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﺃﻓﻀل ﻤﻥ ﺍﻟﻁﺭﻴﻘﺔ‬: ‫ ﺇﺭﺴﺎل ﺍﻟﺴﺠﻼﺕ ﺍﻟﻤﺤﺩﺜﺔ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬-٢
.‫ﺍﻷﻭﻟﻰ ﺤﻴﺙ ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﺒﺎﺭﺴﺎل ﺍﻟﺴﺠﻼﺕ ﺍﻟﺘﻲ ﺘﻡ ﺘﺤﺩﻴﺜﻬﺎ ﻓﻘﻁ‬
‫ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﺇﺭﺴﺎل ﺍﻟﺼﻔﻭﻑ ﺍﻟﻤﺘﺄﺜﺭﺓ ﺒﺎﻟﺘﺤﺩﻴﺜﺎﺕ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻟﻰ‬
: ‫ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
Info=False"
Try
Myds.Tables("Person").Rows.Add(New Object() {Nothing,
"‫"ﺣﺎرث‬, "Harith"})
If Myds.HasChanges Then
Dim AffectedDS As DataSet = Myds.GetChanges
Dim ComBuilder As New
OleDb.OleDbCommandBuilder(daPerson)
daPerson.InsertCommand = ComBuilder.GetInsertCommand
daPerson.Update(AffectedDS, "Person")
End If
MessageBox.Show(e1.Message)
End Try
: ‫ﺍﻟﻔﺎﺭﻕ ﺒﻴﻥ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻷﻭﻟﻰ ﻭﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ‬
‫ ﻟﻨﺭﻯ ﻫل ﺘﻡ ﺘﺤﺩﻴﺙ ﺃﻱ ﺼﻑ ﻤﻥ ﺼﻔﻭﻑ‬Haschanges ‫ ﻗﻤﻨﺎ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻁﺭﻴﻘﺔ‬-١
.‫ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺃﻡ ﻻ‬
‫ ﺒﻌﺩ ﺫﻟﻙ ﻗﻤﻨﺎ ﺒﺘﻌﺭﻴﻑ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ ﻟﻜﻲ ﺘﺤﻭﻱ ﺍﻟﺼﻔﻭﻑ ﺍﻟﺘﻲ ﺘﻡ ﺘﺤﺩﻴﺜﻬﺎ ﻓﻘﻁ ﻭﻫﻭ‬-٢
‫ ﺍﺴﺘﻁﻌﻨﺎ ﺍﺴﺘﺭﺠﺎﻉ ﺍﻟﺼﻔﻭﻑ ﺍﻟﺘﻲ ﺘﻡ ﺘﺤﺩﻴﺜﻬﺎ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻁﺭﻴﻘﺔ‬.‫ﺼﻑ ﻭﺍﺤﺩ ﻓﻘﻁ‬
.‫ ﻭﺍﻟﺘﻲ ﺴﺘﻘﻭﻡ ﺒﺎﺴﺘﺭﺠﺎﻉ ﺍﻟﺼﻔﻭﻑ ﺍﻟﺘﻲ ﺘﻡ ﺘﺤﺩﻴﺜﻬﺎ ﻓﻘﻁ‬Getchanges
.‫ ﻗﻤﻨﺎ ﺒﺈﺭﺴﺎل ﺍﻟﺼﻔﻭﻑ ﺍﻟﻤﺤﺩﺜﺔ ﻓﻘﻁ ﻟﻴﺘﻡ ﺘﺤﺩﻴﺙ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‬-٣
187
‫ﺤل ﺍﻟﺘﻌﺎﺭﺽ ﻓﻲ ﺘﺤﺩﻴﺙ ﺍﻟﺒﻴﺎﻨﺎﺕ‬

‫ﻓﻴﻤﺎ ﺴﺒﻕ ﻤﻥ ﺍﻷﻤﺜﻠﺔ ﻜﻨﺎ ﻨﻔﺘﺭﺽ ﺃﻥ ﺍﻟﻤﺴﺘﺨﺩﻡ ﻫﻭ ﺍﻟﻭﺤﻴﺩ ﺍﻟﺫﻱ ﻴﻘﻭﻡ ﺒﺘﺤﺩﻴﺙ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‪،‬‬
‫ﻟﻜﻥ ﻫﺫﺍ ﺍﻻﻓﺘﺭﺍﺽ ﻓﻲ ﺍﻟﻭﺍﻗﻊ ﻗﺩ ﻻ ﻴﻜﻭﻥ ﺼﺤﻴﺤﺎ‪ .‬ﻋﻨﺩ ﺍﻟﻌﻤل ﺍﻟﺠﻤﺎﻋﻲ ﻋﻠﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ﺴﻭﻑ ﺘﺤﺼل ﺘﻀﺎﺭﺒﺎﺕ ﻋﻨﺩ ﻤﺤﺎﻭﻟﺔ ﺘﺤﺩﻴﺙ ﻨﻔﺱ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻥ ﻗﺒل ﺃﻜﺜﺭ ﻤﻥ ﻤﺴﺘﺨﺩﻡ ﻭﻫﻭ ﻤﺎ‬
‫ﻴﺘﻁﻠﺏ ﺇﻴﺠﺎﺩ ﺤل ﻟﻬﺫﻩ ﺍﻟﺘﻀﺎﺭﺒﺎﺕ‪ ،‬ﺃﻨﺕ ﻏﻨﻲ ﻋﻥ ﺍﻟﺘﻌﺭﻴﻑ ﺃﻨﻨﺎ ﺤﻴﻥ ﻨﻌﻤل ﻤﻊ ﻤﺠﻤﻭﻋﺔ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻨﺤﻥ ﻨﻌﻤل ﻓﻲ ﺍﻟﺒﻴﺌﺔ ﺍﻟﻤﻨﻔﺼﻠﺔ‪ .‬ﻤﺎﺫﺍ ﻟﻭ ﺃﻥ ﻤﺴﺘﺨﺩﻤﺎ ﺍﺴﺘﺭﺠﻊ ﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﻭﻅﻑ ﺨﺎﻟﺩ ﻭ‬
‫ﻗﺎﻡ ﻤﻭﻅﻑ ﺁﺨﺭ ﺒﺎﺴﺘﺭﺠﺎﻉ ﻨﻔﺱ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ ،‬ﺜﻡ ﻗﺎﻡ ﺍﻟﻤﻭﻅﻑ ﺍﻷﻭل ﺒﺘﻌﺩﻴل ﺍﺴﻡ ﺨﺎﻟﺩ ﻓﻲ ﻤﺠﻤﻭﻋﺔ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﺇﻟﻰ ﻋﻠﻲ ﻭﺒﻌﺩ ﺫﻟﻙ ﻗﺎﻡ ﺒﺘﺤﺩﻴﺙ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﻨﻔﺱ ﺍﻟﻭﻗﺕ ﻗﺎﻡ ﺍﻟﻤﻭﻅﻑ ﺍﻵﺨﺭ‬
‫ﺒﺘﻌﺩﻴل ﺍﺴﻡ ﺨﺎﻟﺩ ﺇﻟﻰ ﻤﺤﻤﺩ‪ ،‬ﻫﻨﺎ ﺴﻭﻑ ﻴﺤﺼل ﺘﻀﺎﺭﺏ ﻓﻲ ﺍﻟﺘﻌﺩﻴل‪.‬‬
‫ﻋﻨﺩﻤﺎ ﻴﺠﺩ ﺃﻤﺭ ﺍﻟﺘﺤﺩﻴﺙ ﺃﻨﻪ ﺤﺼل ﺘﻌﺎﺭﺽ ﻓﻲ ﺍﻟﺘﺤﺩﻴﺙ ﻓﺈﻨﻪ ﻴﺘﻭﻗﻑ ﻋﻥ ﺘﺤﺩﻴﺙ ﺒﺎﻗﻲ‬
‫ﺍﻟﺼﻔﻭﻑ ﻭ ﻴﻨﺘﻘل ﺇﻟﻰ ﺴﻴﺎﻕ ﺍﻻﺴﺘﺜﻨﺎﺀ‪ ،‬ﻟﺫﻟﻙ ﻤﻥ ﺍﻟﻤﻬﻡ ﺠﺩﺍ ﺃﻥ ﺘﻀﻊ ﻋﻤﻠﻴﺔ ﺘﺤﺩﻴﺙ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ‬
‫ﺴﻴﺎﻕ ﺍﺴﺘﺜﻨﺎﺀ‪ .‬ﻓﻲ ﺃﻏﻠﺏ ﺍﻷﺤﻴﺎﻥ ﺘﺭﻏﺏ ﺃﻥ ﺘﺘﻡ ﻋﻤﻠﻴﺔ ﺘﺤﺩﻴﺙ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻋﻨﺩ ﺤﺼﻭل ﺘﻌﺎﺭﺽ‬
‫ﻓﻲ ﺘﺤﺩﻴﺙ ﺼﻑ ﻤﺎ ﻴﺘﻡ ﺍﻻﻨﺘﻘﺎل ﺇﻟﻰ ﺍﻟﺼﻑ ﺍﻟﺫﻱ ﻴﻠﻴﻪ ﺤﺘﻰ ﻴﺘﻡ ﺍﻻﻨﺘﻬﺎﺀ ﻤﻥ ﺘﺤﺩﻴﺙ ﻜل ﺼﻔﻭﻑ‬
‫ﺍﻟﺠﺩﻭل ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ ،‬ﻫﺫﺍ ﻤﺎ ﺘﺴﺘﻁﻴﻊ ﻋﻤﻠﻪ ﻤﻥ ﺨﻼل ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺨﺎﺼﻴﺔ‬
‫‪ ContinueUpdateOnError‬ﻭﻫﻲ ﺃﺤﺩ ﺨﻭﺍﺹ ﻤﻬﻲﺀ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﻜﻴﻔﻴﺔ ﺍﺴﺘﺨﺩﺍﻡ ﺨﺎﺼﻴﺔ ‪: ContinueUpdateOnError‬‬

‫‪daPerson.ContinueUpdateOnError = Tru‬‬
‫)"‪daPerson.Update(Myds, "Person‬‬
‫‪If Myds.HasChanges Then‬‬
‫‪End If‬‬
‫ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﻤﻨﺎ ﺒﻤﺎ ﻴﻠﻲ ‪:‬‬
‫‪ -١‬ﺇﻋﻤﺎل ﺨﺎﺼﻴﺔ ‪ ContinueUpdateOnError‬ﻭ ﺍﻟﺘﻲ ﺴﻭﻑ ﺘﻤﻜﻥ ﻤﻥ ﺍﻻﻨﺘﻘﺎل ﺇﻟﻰ‬
‫ﺍﻟﺼﻑ ﺍﻟﺘﺎﻟﻲ ﻓﻲ ﺤﺎﻟﺔ ﺤﺩﻭﺙ ﺘﻌﺎﺭﺽ ﻓﻲ ﺘﺤﺩﻴﺙ ﺍﻟﺒﻴﺎﻨﺎﺕ‪.‬‬
‫‪ -٢‬ﻗﻤﻨﺎ ﺒﺘﺤﺩﻴﺙ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫‪ -٣‬ﻭﻀﻌﻨﺎ ﺍﻟﺸﺭﻁ ﺍﻟﺫﻱ ﺴﻭﻑ ﻴﺒﻴﻥ ﻟﻨﺎ ﻫل ﺤﺩﺙ ﺘﻌﺎﺭﺽ ﺃﻡ ﻻ‪ ،‬ﺇﺫﺍ ﺘﺤﻘﻕ ﻫﺫﺍ ﺍﻟﺸﺭﻁ ﻓﻘﺩ‬
‫ﺤﺩﺙ ﺘﻌﺎﺭﺽ ﻭﻫﻭ ﻤﺎ ﻴﺘﻁﻠﺏ ﻤﻨﺎ ﺤل ﻫﺫﺍ ﺍﻟﺘﻌﺎﺭﺽ‪.‬‬
‫‪188‬‬
‫ﻋﺭﺽ ﺍﻟﺼﻔﻭﻑ ﺍﻟﺘﻲ ﻟﻡ ﻴﺘﻡ ﺘﺤﺩﻴﺜﻬﺎ‬

‫ﻋﻨﺩ ﺤﺩﻭﺙ ﺘﻌﺎﺭﺽ ﻓﻲ ﺘﺤﺩﻴﺙ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻴﺘﻭﺠﺏ ﻋﻠﻴﻙ ﻋﺭﺽ ﻫﺫﻩ ﺍﻟﺼﻔﻭﻑ ﺍﻟﺘﻲ ﻟﻡ ﻴﺘﻡ ﺘﺤﺩﻴﺜﻬﺎ‬
.‫ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﻊ ﺇﻴﻀﺎﺡ ﻟﺴﺒﺏ ﻋﺩﻡ ﺍﻟﺘﺤﺩﻴﺙ ﺤﺘﻰ ﻴﺴﺘﻁﻴﻊ ﺍﻟﻤﺴﺘﻔﻴﺩ ﺍﺘﺨﺎﺫ ﻗﺭﺍﺭ ﻤﺎ‬
: ‫ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﻜﻴﻔﻴﺔ ﻋﺭﺽ ﺍﻟﺼﻔﻭﻑ ﺍﻟﻤﺘﻌﺎﺭﻀﺔ‬

‫ ﻜﻤﺎ ﻴﺘﻀﺢ ﻤﻥ ﺍﻟﺠﺩﻭل‬،‫ ﻗﻡ ﺒﺈﻀﺎﻓﺔ ﻨﻤﻭﺫﺝ ﺠﺩﻴﺩ ﺜﻡ ﺃﻀﻑ ﺯﺭﻱ ﺃﻤﺭ ﻋﻠﻰ ﻫﺫﺍ ﺍﻟﻨﻤﻭﺫﺝ‬-١
: ‫ﺍﻟﺘﺎﻟﻲ‬
cmdGetData Name Button1
‫ﺍﺤﻀﺎﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﺘﺤﺩﻴﺙ ﺼﻑ‬ Text
cmdUpdate Name Button1
‫ﻤﺤﺎﻭﻟﺔ ﺘﺤﺩﻴﺙ ﺍﻟﺒﻴﺎﻨﺎﺕ‬ Text
ResolveConfilct Name Form
: ‫ﻫﺫﺍ ﻫﻭ ﺍﻟﻜﻭﺩ ﻟﻠﺒﺭﻨﺎﻤﺞ ﻜﺎﻤﻼ‬

Public Class ResolveConfilct
Dim dtPerson As DataTable
Dim dr As DataRow
Private Sub cmdUpdate_Click(ByVal sender As System.Object, ByVal e
As System.EventArgs) Handles cmdUpdate.Click
Try
If Myds.HasChanges Then
Dim AffectedDS As DataSet = Myds.GetChanges
Dim ComBuilder As New OleDb.OleDbCommandBuilder(daPerson)
daPerson.ContinueUpdateOnError = True
daPerson.UpdateCommand = ComBuilder.GetUpdateCommand
daPerson.Update(AffectedDS, "Person")
Dim ConflictRow As DataRow
Dim ConfilctRowCount As Integer =
AffectedDS.Tables("Person").GetChanges.Rows.Count
For Each ConflictRow In AffectedDS.Tables("Person").Rows
If ConflictRow.RowState = DataRowState.Modified Then
MessageBox.Show(" ‫ & "اﻟﺼﻒ ﲢﺪﻳﺚ ﰲ ﺧﻄﺄ ﺣﺪث‬ConflictRow(1), "‫ﲢﺪﻳﺚ ﺗﻌﺎرض‬
‫"اﻟﺒﻴﺎﻧﺎت‬, "‫)"ﺗﻌﺎرض‬
End If
Next
End If
MessageBox.Show(e1.Message)
189
End Try
Private Sub cmdGetData_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles cmdGetData.Click
Info=False"
dtPerson = Myds.Tables(0)
dr = dtPerson.Rows(dtPerson.Rows.Count - 1)
dr("name") = "‫"ﻋﺒﺪاﻟﻠـﻪ‬
dr("ename") = "Abduallah"
End Sub
: ‫ﺴﻭﻑ ﻨﺸﺭﺡ ﺍﻵﻥ ﺍﻟﻜﻭﺩ ﺍﻟﺫﻱ ﺒﺨﻁ ﻋﺭﻴﺽ ﻷﻥ ﺒﺎﻗﻲ ﺍﻟﻜﻭﺩ ﺴﺒﻕ ﺸﺭﺤﻪ‬
‫ ﻋﺭﻓﻨﺎ ﻤﺘﻐﻴﺭﺍ ﻤﻥ ﻨﻭﻉ ﺼﻑ ﻟﻜﻲ ﻨﺴﺘﺨﺩﻤﻪ ﻓﻲ ﺃﺨﺫ ﻗﻴﻤﺔ ﺍﻟﺼﻔﻭﻑ ﺍﻟﺘﻲ ﺤﺩﺙ ﻓﻴﻬﺎ ﺘﻌﺎﺭﺽ‬-١
‫ ﻋﺭﻓﻨﺎ ﻤﺘﻐﻴﺭﺍ ﻤﻥ ﻨﻭﻉ ﺭﻗﻡ ﺼﺤﻴﺢ ﺜﻡ ﺍﺴﺘﺭﺠﻌﻨﺎ ﻋﺩﺩ ﺍﻟﺼﻔﻭﻑ ﺍﻟﺘﻲ ﺤﺩﺙ ﻟﻬﺎ ﺘﻌﺎﺭﺽ‬-٢
.‫ﻓﻲ ﺍﻟﺘﺤﺩﻴﺙ‬
‫ ﻋﻤﻠﻨﺎ ﺘﻜﺭﺍﺭ ﻻﺴﺘﺨﺭﺍﺝ ﻜل ﺍﻟﺼﻔﻭﻑ ﺍﻟﺘﻲ ﺤﺩﺙ ﻟﻬﺎ ﺘﻌﺎﺭﺽ ﻭﻤﻥ ﺜﻡ ﺴﻭﻑ ﻴﺘﻡ ﻋﺭﺽ‬-٣
.‫ﻫﺫﺍ ﺍﻟﺘﻌﺎﺭﺽ ﻟﻠﻤﺴﺘﻔﻴﺩ ﻓﻲ ﺭﺴﺎﻟﺔ‬
190
‫‪ ADO.NET‬ﻭ ‪XML‬‬
‫ﻤﻘﺩﻤﺔ ﻋﻥ ‪XML‬‬
‫ﻴﻤﻜﻥ ﺘﻌﺭﻴﻑ ‪ XML‬ﺒﺄﻨﻪ ﻤﻌﻴﺎﺭ ﻟﻭﺼﻑ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺍﻟﺭﻗﻤﻴﺔ‪ .‬ﻴﺘﻡ ﺘﻤﺜﻴل ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺩﺍﺨل ﻤﻠﻔﺎﺕ‬
‫‪ XML‬ﺒﺸﻜل ﻫﺭﻤﻲ ﻤﻤﺎ ﻴﺴﻬل ﻋﻤﻠﻴﺔ ﻗﺭﺍﺀﺘﻬﺎ ﻭ ﺍﻟﺒﺤﺙ ﻓﻴﻬﺎ‪ .‬ﺘﺠﺩﺭ ﺍﻹﺸﺎﺭﺓ ﺇﻟﻰ ﺃﻥ ﻫﻨﺎﻙ ﻓﺎﺭﻗﺎ‬
‫ﻜﺒﻴﺭﺍ ﺒﻴﻥ ﻤﻠﻔﺎﺕ ‪ HTML‬ﻭﻤﻠﻔﺎﺕ ‪ .XML‬ﺘﺴﺘﺨﺩﻡ ﻤﻠﻔﺎﺕ ‪ HTML‬ﻟﺘﻭﻀﻴﺢ ﻜﻴﻔﻴﺔ ﻋﺭﺽ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﻋﻠﻰ ﺍﻟﻤﺘﺼﻔﺢ ﻟﻜﻨﻬﺎ ﻓﻲ ﻨﻔﺱ ﺍﻟﻭﻗﺕ ﻻ ﺘﻤﺘﻠﻙ ﺃﻱ ﻤﻌﻠﻭﻤﺔ ﻋﻥ ﺍﻟﻤﺤﺘﻭﻯ ﺍﻟﺫﻱ ﻴﺘﻡ ﻋﺭﻀﻪ‪.‬‬
‫ﻋﻠﻰ ﺍﻟﻨﻘﻴﺽ ﻤﻥ ﺫﻟﻙ ﺘﺴﺘﺨﺩﻡ ﻤﻠﻔﺎﺕ ‪ XML‬ﻟﻌﺭﺽ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻜﻤﺎ ﺃﻨﻬﺎ ﺘﺤﻭﻱ ﻤﻌﻠﻭﻤﺎﺕ ﻋﻥ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﻤﻌﺭﻭﻀﺔ‪ .‬ﺘﻡ ﺘﺼﻤﻴﻡ ‪ XML‬ﻟﻨﻘل ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﺨﻼل ﺍﻻﻨﺘﺭﻨﺕ ﺒﺎﻹﻀﺎﻓﺔ ﺇﻟﻰ ﺍﻟﻬﻴﻜل‬
‫ﺍﻟﺨﺎﺹ ﺒﻬﺎ ‪ XSD‬ﻭﺍﻟﺫﻱ ﻴﺒﻴﻥ ﻤﺤﺘﻭﺍﻫﺎ ﻟﻤﺘﻠﻘﻲ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﻜﻤﺎ ﺃﻥ ﻫﻨﺎﻙ ﻓﺎﺭﻗﺎ ﺁﺨﺭ ﻭﻫﻭ ﺃﻥ ‪XML‬‬
‫ﺘﻤﻜﻥ ﺍﻟﻤﺴﺘﻔﻴﺩ ﻤﻥ ﺒﻨﺎﺀ ﺍﻟﻬﻴﻜل ﺍﻟﺫﻱ ﻴﺭﻴﺩ ﻓﺈﻥ ‪ HTML‬ﺘﺤﻭﻱ ﻋﺩﺩﺍ ﻤﺤﺩﻭﺩﺍ ﻤﻥ ﺍﻟﻌﻼﻤﺎﺕ ﺍﻟﻤﻬﻴﺌﺔ‬
‫ﻟﻺﺴﺘﺨﺩﺍﻡ‪ .‬ﺘﻌﺘﺒﺭ ‪ XML‬ﺘﻘﻨﻴﺔ ﻤﺩﻋﻭﻤﺔ ﺒﺸﻜل ﻜﺒﻴﺭ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‪ ،‬ﻴﻭﺠﺩ ﻓﺌﺎﺕ ﺨﺎﺼﺔ ﺒــ‬
‫‪ XML‬ﻤﺭﺘﺒﻁﺔ ﺒـ ‪ .ADO.NET‬ﻤﻥ ﺃﻫﻡ ﻤﺎ ﻴﻤﻴﺯ ‪ XML‬ﺃﻨﻬﺎ ﻤﻠﻔﺎﺕ ﻨﺼﻴﺔ ﻭ ﻫﻭ ﻤﺎ ﻴﺠﻌل ﻨﻘل‬
‫ﻫﺫﻩ ﺍﻟﻤﻠﻔﺎﺕ ﺒﻴﻥ ﺃﻨﻅﻤﺔ ﺍﻟﺘﺸﻐﻴل ﻭ ﺍﻟﺘﻁﺒﻴﻘﺎﺕ ﺃﻤﺭﺍ ﻴﺴﻴﺭﺍ‪.‬‬
‫ﻨﻅﺭﺓ ﻋﻠﻰ ﻤﻠﻑ ‪XML‬‬

‫ﻴﻤﺜل ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻨﻤﻭﺫﺠﺎ ﻟﻤﻠﻑ ‪XML‬‬
‫>?"‪<?xml version="1.0" standalone="yes‬‬
‫>‪<NewDataSet‬‬
‫>‪<Person‬‬
‫>‪<id>1</id‬‬
‫>‪</name‬ﺧﺎﻟﺪ>‪<name‬‬
‫>‪</Person‬‬
‫>‪<id>2</id‬‬
‫>‪</name‬اﲪﺪ>‪<name‬‬
‫>‪</NewDataSet‬‬
‫ﻗﻤﻨﺎ ﺒﺈﻨﺘﺎﺝ ﻫﺫﺍ ﺍﻟﻤﻠﻑ ﻤﻥ ﺨﻼل ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭﻫﻭ ﻤﺎ ﺴﺘﺭﺍﻩ ﻻﺤﻘﺎ‪ ،‬ﻴﺤﻭﻱ ﻫﺫﺍ ﺍﻟﻤﻠﻑ ﻋﻠﻰ‬
‫ﺼﻔﻴﻥ‪ ،‬ﻜﻤﺎ ﺘﺭﻯ ﻓﺈﻥ ﻫﺫﺍ ﺍﻟﻤﻠﻑ ﺴﻬل ﺍﻟﻔﻬﻡ ﻓﺎﻟﺒﻴﺎﻨﺎﺕ ﻤﻌﺭﻭﻀﺔ ﺒﺸﻜل ﻫﺭﻤﻲ ﻭﺍﻀﺢ‪ .‬ﻴﻭﺠﺩ‬
‫ﻤﻭﻅﻔﺎﻥ ﺍﻷﻭل ﺍﺴﻤﻪ ﺨﺎﻟﺩ ﻭ ﺍﻟﺜﺎﻨﻲ ﺍﺴﻤﻪ ﺃﺤﻤﺩ‪ ،‬ﻻﺤﻅ ﻭﺠﻭﺩ ﻜﻠﻤﺔ ‪ name‬ﻗﺒل ﺍﻻﺴﻡ ﻭﻜﻠﻤﺔ ‪ id‬ﻗﺒل‬
‫ﺍﻟﺭﻗﻡ‪ .‬ﻫﺎﺘﺎﻥ ﺍﻟﻜﻠﻤﺘﺎﻥ ﺘﻤﺜﻼﻥ ﺍﺴﻤﺎ ﺍﻟﺤﻘل ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‪ .‬ﺃﻤﺎ ﻜﻠﻤﺔ ‪ Person‬ﻓﺘﻤﺜل ﺍﺴﻡ‬
‫ﺍﻟﺠﺩﻭل‪.‬‬
‫‪192‬‬
‫ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ‪XML‬‬

‫ﺘﻭﻓﺭ ﻟﻨﺎ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻤﺠﻤﻭﻋﺔ ﻤﻥ ﺍﻟﻁﺭﻕ ﻟﻠﺘﻌﺎﻤل ﻤﻊ ﻤﻠﻔﺎﺕ ‪ XML‬ﻜﻤﺎ ﻴﻠﻲ ‪:‬‬
‫‪ -١‬ﺘﺴﺘﻁﻴﻊ ﻜﺘﺎﺒﺔ ﻤﺎ ﺘﺤﺘﻭﻴﻪ ﻤﻥ ﺒﻴﺎﻨﺎﺕ ﻓﻲ ﻤﻠﻑ ‪.XML‬‬
‫‪ -٢‬ﺘﺴﺘﻁﻴﻊ ﻗﺭﺍﺀﺓ ﻤﻠﻑ ‪ XML‬ﻭﻤﻥ ﺜﻡ ﺘﻌﺒﺌﺘﻪ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ‪.‬‬
‫ﻜﺘﺎﺒﺔ ﻤﺤﺘﻭﻯ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ ﻓﻲ ‪XML‬‬

‫ﺍﻟﻁﺭﻴﻘﺔ ﺍﻷﺴﺎﺴﻴﺔ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﻜﺘﺎﺒﺔ ﻤﻠﻑ ‪ XML‬ﻫﻲ ‪ .WriteXML‬ﻟﺘﻭﻀﻴﺢ ﻜﻴﻔﻴﺔ‬
‫ﺍﺴﺘﺨﺩﺍﻡ ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﺴﻭﻑ ﻨﺄﺨﺫ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ‪:‬‬
‫)(‪Dim Myds As New DataSet‬‬
‫"‪Dim sql As String = "select id,name from person where id=1‬‬
‫‪Try‬‬
‫)‪Dim daPerson As New OleDb.OleDbDataAdapter(sql, con‬‬
‫)"‪daPerson.Fill(Myds, "Person‬‬
‫)"‪Myds.WriteXml("dsPerson.xml‬‬
‫‪End Try‬‬
‫‪ -١‬ﺃﻋﻠﻨﺎ ﻋﻥ ﺍﺘﺼﺎل ﻭ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ‬
‫‪ -٢‬ﻓﻲ ﺍﻟﺴﻁﺭ ﺍﻟﺜﺎﻟﺙ ﻋﺭﻓﻨﺎ ﺠﻤﻠﺔ ﺍﻻﺴﺘﻌﻼﻡ ﻭﺍﻟﺘﻲ ﻴﺠﺏ ﺃﻥ ﺘﺭﺠﻊ ﻟﻨﺎ ﻤﻭﻅﻔﺎ ﻭﺍﺤﺩ‬
‫‪ -٣‬ﻨﻔﺫﻨﺎ ﺍﻻﺴﺘﻌﻼﻡ ﺜﻡ ﻭﻀﻌﻨﺎ ﻨﺘﻴﺠﺔ ﺍﻻﺴﺘﻌﻼﻡ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫‪ -٤‬ﻗﻤﻨﺎ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻁﺭﻴﻘﺔ ‪ WriteXml‬ﻟﻜﺘﺎﺒﺔ ﻤﺤﺘﻭﻯ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﻤﻠﻑ ‪XML‬‬
‫ﺍﺴﻤﻪ ‪ ، dsPerson.xml‬ﺴﻭﻑ ﻴﺘﻡ ﺍﻨﺸﺎﺀ ﺍﻟﻤﻠﻑ ﻓﻲ ﺍﻟﻤﺠﻠﺩ ‪ Bin‬ﻭ ﺍﻟﺫﻱ ﻴﻘﻊ ﺩﺍﺨل ﻤﺠﻠﺩ‬
‫ﺍﻟﻤﺸﺭﻭﻉ‪.‬‬
‫‪ -٥‬ﻫﺫﺍ ﻫﻭ ﻤﺤﺘﻭﻯ ﻤﻠﻑ ‪ XML‬ﺍﻟﻨﺎﺘﺞ ﻤﻥ ﺍﻟﻜﻭﺩ ﺍﻟﺴﺎﺒﻕ‪.‬‬
‫>?"‪<?xml version="1.0" standalone="yes‬‬
‫>‪<NewDataSet‬‬
‫>‪<id>1</id‬‬
‫>‪</name‬ﺧﺎﻟﺪ>‪<name‬‬
‫>‪</NewDataSet‬‬
‫‪193‬‬
‫ﻗﺭﺍﺀﺓ ﻤﻠﻑ ‪XML‬‬

‫ﻟﻘﺭﺍﺀﺓ ﻤﻠﻑ ‪ XML‬ﻭ ﻤﻥ ﺜﻡ ﻜﺘﺎﺒﺘﻪ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ ﺍﺴﺘﺨﺩﻡ ﺍﻟﻁﺭﻴﻘﺔ ‪.ReadXml‬‬
‫)"‪Myds.WriteXml("dsPerson.XML‬‬
‫)(‪Dim ds As New DataSet‬‬
‫)"‪ds.ReadXml("dsPerson.XML‬‬
‫‪ -١‬ﻜﺘﺎﺒﺔ ﻤﻠﻑ ‪XML‬‬
‫‪ -٢‬ﻋﺭﻓﻨﺎ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ ﺠﺩﻴﺩﺓ‬
‫‪ -٣‬ﻗﻤﻨﺎ ﺒﻘﺭﺍﺀﺓ ﻤﺤﺘﻭﻯ ﺍﻟﻤﻠﻑ ﺇﻟﻰ ﻫﺫﻩ ﺍﻟﻤﺠﻤﻭﻋﺔ‬
‫ﺍﺴﺘﺭﺠﺎﻉ ﻤﺤﺘﻭﻯ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻋﻠﻰ ﺸﻜل ‪XML‬‬

‫ﻻﺴﺘﺭﺠﺎﻉ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻋﻠﻰ ﺸﻜل ‪ XML‬ﻗﻡ ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻁﺭﻴﻘﺔ ‪ .Getxml‬ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻴﻘﻭﻡ‬
‫ﺒﻌﺭﺽ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻋﻠﻰ ﺸﻜل ‪ xml‬ﻓﻲ ﻤﺭﺒﻊ ﻨﺹ‪ .‬ﻜﻤﺎ ﺘﻼﺤﻅ ﻋﺭﺽ ﻤﻠﻑ ‪ XML‬ﻓﻲ‬
‫ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﺸﻲﺀ ﻴﺴﻴﺭ ﺠﺩﺍ ﻓﻤﺠﺭﺩ ﺃﻥ ﺘﻌﻴﻥ ﻤﻠﻑ ‪ XML‬ﻟﺨﺎﺼﻴﺔ ‪ Text‬ﺍﻟﺨﺎﺼﺔ ﺒﻤﺭﺒﻊ ﺍﻟﻨﺹ‬
‫ﻓﺈﻥ ﺫﻟﻙ ﻜﻔﻴل ﺒﻌﺭﺽ ﻫﺫﺍ ﺍﻟﻤﻠﻑ‪.‬‬
‫‪TextBox1.Text = Myds.GetXml‬‬
‫ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺴﺎﺒﻕ ﻨﻔﺘﺭﺽ ﺃﻨﻪ ﺘﻡ ﺇﻨﺸﺎﺀ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ ﺜﻡ ﻤﻠﺌﻬﺎ ﻤﻥ ﺠﺩﻭل ﺍﻷﺸﺨﺎﺹ ﺒﻌﺩ ﺫﻟﻙ‬
‫ﺍﺴﺘﺨﺩﻤﻨﺎ ﺍﻟﻁﺭﻴﻘﺔ ‪ GetXml‬ﻭ ﺍﻟﺘﻲ ﺘﻘﻭﻡ ﺒﺎﺴﺘﺭﺠﺎﻉ ﻤﺤﺘﻭﻯ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻋﻠﻰ ﺸﻜل ‪XML‬‬
‫ﺜﻡ ﻋﺭﻀﻨﺎ ﺫﻟﻙ ﻋﻠﻰ ﻤﺭﺒﻊ ﻨﺹ‪.‬‬
‫ﺍﺴﺘﺭﺠﺎﻉ ﻫﻴﻜل ‪ XML‬ﻟﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ‬

‫ﺇﺫﺍ ﺍﺭﺩﺕ ﺍﺴﺘﺭﺠﺎﻉ ﻫﻴﻜل ‪ XML‬ﻟﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ ﺍﺴﺘﺨﺩﻡ ﺍﻟﻭﻅﻴﻔﺔ ‪ .GetXmlSchema‬ﻜﻤﺎ ﻴﻠﻲ‬
‫‪TextBox1.Text = Myds. GetXmlSchema‬‬
‫‪194‬‬
XML ‫ﺒﺭﻨﺎﻤﺞ ﺍﻟﺘﻌﺎﻤل ﻤﻊ‬

: ‫ﻟﺘﻁﺒﻴﻕ ﻜل ﺍﻟﻁﺭﻕ ﺍﻟﺴﺎﺒﻘﺔ ﻗﻡ ﺒﺎﻨﺸﺎﺀ ﻨﻤﻭﺫﺝ ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل‬
: ‫ﻀﻊ ﺍﻷﺩﻭﺍﺕ ﻤﻊ ﺇﻋﻁﺎﺌﻬﺎ ﺍﻟﺨﺼﺎﺌﺹ ﺍﻟﺘﺎﻟﻴﺔ‬

cmdWritexml Name Button1
XML ‫ﻜﺘﺎﺒﺔ ﻤﻠﻑ‬ Text
cmdGetXml Name Button1
xml ‫ﻋﺭﺽ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﺸﻜل‬ Text
cmdReadXml Name Button1
XML ‫ﻗﺭﺍﺀﺓ ﻤﻠﻑ‬ Text
cmdGetSchema Name Button1
‫ ﻟﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ‬xml ‫ﺍﺴﺘﺭﺠﺎﻉ ﻫﻴﻜل‬ Text
Label1 Name Label1
Text
TextBox1 Name TextBox
True MultiLine
Both Scrollbars
XML ‫ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺘﻘﻨﻴﺔ‬ Text Form1
Yes RightToLeft
195
‫ﻗﻡ ﺒﻜﺘﺎﺒﺔ ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ‬

Public Class WriteXml
Private Sub cmdWritexml_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles cmdWritexml.Click
Dim sql As String = "select id,name from person where id=1"
Try
Myds.WriteXml("dsPerson.xml")
End Try
End Sub
Private Sub cmdReadXml_Click(ByVal sender As System.Object, ByVal e
As System.EventArgs) Handles cmdReadXml.Click
Myds.WriteXml("dsPerson")
Dim ds As New DataSet()
ds.ReadXml("dsPerson")
End Sub
Private Sub cmdGetXml_Click(ByVal sender As System.Object, ByVal e
As System.EventArgs) Handles cmdGetXml.Click
TextBox1.Text = Myds.GetXml
End Sub
Private Sub cmdGetSchema_Click(ByVal sender As System.Object, ByVal
e As System.EventArgs) Handles cmdGetSchema.Click
TextBox1.Text = Myds.GetXmlSchema
End Sub
End Class
: ‫ﻴﻤﻜﻥ ﺘﻠﺨﻴﺹ ﺃﻫﻡ ﻤﺎ ﻴﻘﻭﻡ ﺒﻪ ﺍﻟﻜﻭﺩ ﻤﻥ ﺨﻼل ﺍﻟﻨﻘﺎﻁ ﺍﻟﺘﺎﻟﻴﺔ‬
‫ ﻻﺤﻅ ﺃﻨﻪ ﻴﻭﺠﺩ ﺃﺭﺒﻌﺔ ﺍﺠﺭﺍﺀﺍﺕ ﻜل ﻭﺍﺤﺩ ﻤﻨﻬﺎ ﺨﺎﺹ ﺒﺤﺩﺙ ﺍﻟﻨﻘﺭ ﻟﺯﺭ ﺃﻤﺭ ﻤﻥ ﺍﻷﺯﺭﺍﺭ‬-١
.‫ﺍﻟﺘﻲ ﺴﺒﻕ ﺇﻨﺸﺎﺅﻫﺎ‬
.XML ‫ ﻜل ﻭﺍﺤﺩ ﻤﻥ ﺍﻹﺠﺭﺍﺀﺍﺕ ﻴﻘﻭﻡ ﺒﺘﻁﺒﻴﻕ ﻁﺭﻴﻘﺔ ﻤﻥ ﻁﺭﻕ ﺍﻟﺘﻌﺎﻤل ﻤﻊ‬-٢
‫ ﻴﻘﻭﻡ ﺒﻜﺘﺎﺒﺔ ﻤﺤﺘﻭﻯ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﻲ ﻤﻠﻑ‬cmdWritexml_Click ‫ ﺍﻹﺠﺭﺍﺀ‬-٣
.XML
‫ ﻓﻲ‬Myds ‫ ﻴﻘﻭﻡ ﺒﻜﺘﺎﺒﺔ ﻤﺤﺘﻭﻯ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬cmdReadXml_Click ‫ ﺍﻻﺠﺭﺍﺀ‬-٤
‫ ﺇﻟﻰ ﻤﺠﻤﻭﻋﺔ‬XML ‫ ﺜﻡ ﻴﻘﻭﻡ ﺒﺈﻨﺸﺎﺀ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ ﺃﺨﺭﻯ ﻭﻗﺭﺍﺀﺓ ﻤﻠﻑ‬XML ‫ﻤﻠﻑ‬
.‫ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ ﻴﻘﻭﻡ ﺒﻘﺭﺍﺀﺓ ﻤﺤﺘﻭﻯ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻋﻠﻰ ﺸﻜل‬cmdGetXml_Click ‫ ﺍﻻﺠﺭﺍﺀ‬-٥
‫ ﺍﻨﻅﺭ ﺍﻟﺸﻜل‬.‫ ﺜﻡ ﻋﺭﻀﻬﺎ ﻋﻠﻰ ﻤﺭﺒﻊ ﻨﺹ‬XML
196
‫‪ -٦‬ﺍﻻﺠﺭﺍﺀ ‪ cmdGetSchema_Click‬ﻴﻘﻭﻡ ﺒﻘﺭﺍﺀﺓ ﻤﺤﺘﻭﻯ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻋﻠﻰ‬

‫ﺸﻜل ﻫﻴﻜل ‪ XML‬ﺜﻡ ﻋﺭﺽ ﻫﺫﺍ ﺍﻟﻬﻴﻜل ﻋﻠﻰ ﻤﺭﺒﻊ ﻨﺹ‪ .‬ﺍﻨﻅﺭ ﺍﻟﺸﻜل‬
‫‪197‬‬
‫ﺇﻨﺸﺎﺀ ﺍﻟﺘﻘﺎﺭﻴﺭ‬
‫ﺘﻌﻠﻤﻨﺎ ﻓﻴﻤﺎ ﺴﺒﻕ ﻤﻥ ﻓﺼﻭل ﻜﻴﻔﻴﺔ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﻜﻥ ﺒﻘﻲ ﺸﻲﺀ ﻭﺍﺤﺩ ﻭﻤﻬﻡ ﻭﻫﻭ ﻜﻴﻔﻴﺔ‬
‫ﻋﺭﺽ ﻭ ﻁﺒﺎﻋﺔ ﺍﻟﺘﻘﺎﺭﻴﺭ‪ .‬ﻟﻌﺭﺽ ﺍﻟﺘﻘﺎﺭﻴﺭ ﺘﻭﺠﺩ ﻫﻨﺎﻙ ﻁﺭﻴﻘﺘﺎﻥ ﺃﺴﺎﺴﻴﺘﺎﻥ ﻭﻫﻤﺎ ‪:‬‬
‫‪ -١‬ﺇﻨﺸﺎﺀ ﺍﻟﺘﻘﺎﺭﻴﺭ ﺨﺎﺭﺝ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﺜﻡ ﺍﺴﺘﺩﻋﺎﺌﻬﺎ ﻭ ﺇﺭﺴﺎل ﺍﻟﻌﻭﺍﻤل ﺍﻟﻤﻨﺎﺴﺒﺔ ﻹﺨﺭﺍﺝ‬
‫ﺍﻟﺘﻘﺭﻴﺭ ‪ :‬ﻓﻌﻠﻰ ﺴﺒﻴل ﺍﻟﻤﺜﺎل ﻟﻭ ﻜﻨﺕ ﻤﺤﺘﺭﻓﺎ ﻓﻲ ﺒﻨﺎﺀ ﺍﻟﺘﻘﺎﺭﻴﺭ ﺒﺎﺴﺘﺨﺩﺍﻡ ﻤﺼﻤﻡ ﺍﻟﺘﻘﺎﺭﻴﺭ ﻓﻲ‬
‫ﻤﺎﻴﻜﺭﻭﺴﻭﻓﺕ ﺃﻜﺴﺱ ﻓﺈﻥ ﺒﺎﺴﺘﻁﺎﻋﺘﻙ ﺒﻨﺎﺀ ﺍﻟﺘﻘﺭﻴﺭ ﺍﻟﺫﻱ ﺘﺭﻴﺩ ﻭﻤﻥ ﺜﻡ ﺍﺴﺘﺩﻋﺎﺀ ﻫﺫﺍ ﺍﻟﺘﻘﺭﻴﺭ‬
‫ﻤﻥ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‪.‬‬
‫‪ -٢‬ﺍﻨﺸﺎﺀ ﺍﻟﺘﻘﺎﺭﻴﺭ ﻤﻥ ﺨﻼل ﻜﺎﺌﻨﺎﺕ ﻜﺭﻴﺴﺘﺎل ﺭﻴﺒﻭﺭﺕ ﻭ ﺍﻟﺘﻲ ﺘﻭﺠﺩ ﻤﻊ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‪.‬‬
‫ﺴﻭﻑ ﻴﻜﻭﻥ ﻤﺤﻭﺭ ﺤﺩﻴﺜﻨﺎ ﻋﻥ ﺍﻟﻁﺭﻴﻘﺔ ﺍﻟﺜﺎﻨﻴﺔ‪.‬‬
‫ﺘﻘﺩﻡ ﺘﻘﺎﺭﻴﺭ ﻜﺭﻴﺴﺘﺎل ﻗﻭﺓ ﻤﻤﺘﺎﺯﺓ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻟﺘﺼﻤﻴﻡ ﺍﻟﺘﻘﺎﺭﻴﺭ‪ .‬ﻴﻭﺠﺩ ﻤﺼﻤﻡ ﻜﺭﻴﺴﺘﺎل‬
‫ﻟﻠﺘﻘﺎﺭﻴﺭ ﻭ ﺍﻟﺫﻱ ﻴﻤﻜﻨﻙ ﻤﻥ ﺍﻨﺸﺎﺀ ﺘﻘﺭﻴﺭ ﺠﺩﻴﺩ ﺃﻭ ﺘﺤﺩﻴﺙ ﺘﻘﺭﻴﺭ ﺴﺒﻕ ﺍﻨﺸﺎﺅﻩ‪ .‬ﺒﻌﺩ ﺇﻨﺸﺎﺌﻙ ﻟﻠﺘﻘﺭﻴﺭ‬
‫ﺘﺴﺘﻁﻴﻊ ﺍﺴﺘﺨﺩﺍﻤﻪ ﻓﻲ ﺘﻁﺒﻴﻘﻙ ﺴﻭﺍﺀ ﻜﺎﻥ ﻫﺫﺍ ﺍﻟﺘﻁﺒﻴﻕ ﺘﻁﺒﻴﻕ ﻤﻜﺘﺒﻲ ﺃﻭ ﺘﻁﺒﻴﻕ ﻴﻌﻤل ﻋﻠﻰ ﺍﻻﻨﺘﺭﻨﺕ‪.‬‬
‫ﺍﻨﺸﺎﺀ ﺘﻘﺭﻴﺭ ﺒﻭﺍﺴﻁﺔ ﻜﺭﻴﺴﺘﺎل ﺭﻴﺒﻭﺭﺕ‬

‫ﻹﻨﺸﺎﺀ ﺘﻘﺭﻴﺭ ﺒﻭﺍﺴﻁﺔ ﻜﺭﻴﺴﺘﺎل ﺭﻴﺒﻭﺭﺕ ﺍﺘﺒﻊ ﺍﻟﺨﻁﻭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ -١‬ﺍﺒﺩﺃ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻭ ﺴﻤﻪ ‪.CrystalDemo‬‬
‫‪ -٢‬ﺃﻀﻑ ﻤﻠﻑ ﻜﺭﻴﺴﺘﺎل ﺠﺩﻴﺩ ﻤﻥ ﺨﻼل ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤﻠﻭل ﻭﺫﻟﻙ ﺒﻨﻘﺭ ﺯﺭ ﺍﻟﻔﺄﺭﺓ ﺍﻷﻴﻤﻥ ﻋﻠﻰ‬
‫ﺍﻟﻤﺸﺭﻭﻉ ﻭﻤﻥ ﺜﻡ ﺍﺨﺘﻴﺎﺭ ‪ Add‬ﻟﻴﻅﻬﺭ ﻟﻙ ﺍﻟﺸﻜل‪ .‬ﻗﻡ ﺒﺘﺴﻤﻴﺔ ﻫﺫﺍ ﺍﻟﻤﻠﻑ ﺒــ‬
‫‪.FirstReport‬‬
‫‪199‬‬
‫‪ -٣‬ﺴﻭﻑ ﺘﻅﻬﺭ ﻟﻙ ﺸﺎﺸﺔ ﻨﻭﻉ ﺍﻟﺘﻘﺭﻴﺭ ﺍﻟﺫﻱ ﺘﺭﻴﺩ ﺒﻨﺎﺌﻪ ﺍﺨﺘﺭ ﻨﻔﺱ ﺍﻻﺨﺘﻴﺎﺭﺍﺕ‬
‫ﺍﻟﺘﻲ ﺘﺭﺍﻫﺎ ﻓﻲ ﺍﻟﺸﻜل ﺜﻡ ﺍﻨﻘﺭ ‪Ok‬‬
‫‪ -٤‬ﺴﻭﻑ ﻴﻅﻬﺭ ﻟﻙ ﺍﻟﺸﻜل ﻭ ﺍﻟﺫﻱ ﻴﻁﻠﺏ ﻤﺼﺩﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﺘﺭﻴﺩ ﺃﻥ ﺘﻨﺸﺄ ﺍﻟﺘﻘﺭﻴﺭ ﻤﻨﻬﺎ‪.‬‬
‫ﺍﺨﺘﺭ‬
‫‪ OLE DB ADO‬ﻜﻤﺎ ﻴﻅﻬﺭ‬
‫‪200‬‬
‫‪ -٤‬ﻟﻜﻲ ﺘﻅﻬﺭ ﻟﻙ ﺸﺎﺸﺔ ﺘﺤﺩﻴﺩ ﻤﺯﻭﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل ‪ ،‬ﺍﺨﺘﺭ ﻤﺯﻭﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
‫ﺍﻟﺨﺎﻟﺹ ﺒﻤﺎﻴﻜﺭﻭﺴﻭﻓﺕ ﺃﻜﺴﺱ ﺍﺨﺘﺭﻩ ﺜﻡ ﺍﻨﻘﺭ ‪ Next‬ﻭﺤﺩﺩ ﻤﻭﻗﻊ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻭ ﺍﺨﺘﺭ‬
‫‪.Ok‬‬
‫‪ -٥‬ﺴﻭﻑ ﺘﻅﻬﺭ ﻜل ﺍﻟﺠﺩﺍﻭل‪ ،‬ﺍﺨﺘﺭ ﺠﺩﻭل ﺍﻷﺸﺨﺎﺹ ﺜﻡ ﺍﻨﻘﺭ ﺍﻟﺘﺎﻟﻲ ﺴﻭﻑ ﻴﻨﺘﻘل ﺠﺩﻭل‬
‫ﺍﻷﺸﺨﺎﺹ ﺇﻟﻰ ﺍﻟﺠﻬﺔ ﺍﻟﻴﻤﻨﻰ‪.‬‬
‫‪201‬‬
‫‪ -٦‬ﺴﻭﻑ ﺘﻅﻬﺭ ﻟﻙ ﺤﻘﻭل ﺍﻟﺠﺩﻭل‪ ،‬ﻫﻨﺎ ﺘﻘﻭﻡ ﺒﺎﺨﺘﻴﺎﺭ ﺍﻟﺤﻘﻭل ﺍﻟﺘﻲ ﺘﺭﻴﺩ ﺃﻥ ﺘﻅﻬﺭ ﻓﻲ ﺍﻟﺘﻘﺭﻴﺭ‪،‬‬
‫ﺍﺨﺘﺭ ﻜل ﺍﻟﺤﻘﻭل ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل‬
‫‪ -٧‬ﺍﻨﻘﺭ ﺍﻟﺘﺎﻟﻲ ﻟﺘﻅﻬﺭ ﻟﻙ ﺸﺎﺸﺔ ﺨﻴﺎﺭﺍﺕ ﺍﻟﺘﺠﻤﻴﻊ ﻓﻲ ﺍﻟﺘﻘﺭﻴﺭ ‪ :‬ﺘﻌﺘﺒﺭ ﻫﺫﻩ ﺍﻟﺨﻁﻭﺓ ﺍﺨﺘﻴﺎﺭﻴﺔ‬
‫‪ ,‬ﻭﻴﻤﻜﻨﻙ ﻤﻥ ﺨﻼﻟﻬﺎ ﺍﺨﺘﻴﺎﺭ ﺍﻟﺤﻘل ﺍﻟﺫﻱ ﺘﺭﻴﺩ ﺍﺠﺭﺍﺀ ﺍﻟﺘﺠﻤﻴﻊ ﺒﻪ‪ .‬ﺍﻨﻘﺭ ﺍﻟﺘﺎﻟﻲ‪.‬‬
‫‪202‬‬
‫‪ -٨‬ﺴﻭﻑ ﺘﻅﻬﺭ ﻟﻙ ﺸﺎﺸﺔ ﺍﻟﺘﺭﺸﻴﺢ ‪ :‬ﺘﻌﺘﺒﺭ ﻫﺫﻩ ﺍﻟﺸﺎﺸﺔ ﺍﺨﺘﻴﺎﺭﻴﺔ ﻭ ﺘﺴﺘﻁﻴﻊ ﻤﻥ ﺨﻼﻟﻬﺎ ﺘﺭﺸﻴﺢ‬
‫ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﺴﺘﺨﺭﺝ ﻓﻲ ﺍﻟﺘﻘﺭﻴﺭ ﻤﻥ ﺨﻼل ﻭﻀﻊ ﺸﺭﻁ ﻤﺎ ﻋﻠﻰ ﺃﻱ ﻤﻥ ﺍﻟﺤﻘﻭل‪ ،‬ﻓﻲ‬
‫ﺘﻘﺭﻴﺭﻨﺎ ﻫﺫﺍ ﺴﻨﻘﻭﻡ ﺒﻌﺭﺽ ﻜﺎﻓﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻟﺫﻟﻙ ﺍﻨﻘﺭ ﺍﻟﺘﺎﻟﻲ‬
‫‪ -٩‬ﺸﺎﺸﺔ ﺘﻨﺴﻴﻕ ﺍﻟﺘﻘﺭﻴﺭ ‪ :‬ﺘﻤﻜﻨﻙ ﻫﺫﻩ ﺍﻟﺸﺎﺸﺔ ﻤﻥ ﺘﺤﺩﻴﺩ ﺘﻨﺴﻴﻕ ﺍﻟﺘﻘﺭﻴﺭ‪ ،‬ﻴﻭﺠﺩ ﻋﺩﺓ ﺃﻨﻭﺍﻉ‬
‫ﺘﺴﺘﻁﻴﻊ ﺍﺴﺘﻌﺭﺍﻀﻬﺎ ﻭﻤﻥ ﺜﻡ ﺍﺨﺘﻴﺎﺭ ﺍﻟﺘﻨﺴﻴﻕ ﺍﻟﺫﻱ ﺘﺭﺍﻩ ﻤﻨﺎﺴﺒﺎ‪ ،‬ﺴﻭﻑ ﻨﺨﺘﺎﺭ ﺍﻟﺘﻨﺴﻴﻕ‬
‫ﺍﻟﻘﻴﺎﺴﻲ ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل ‪:‬‬
‫‪203‬‬
‫ﺍﻨﻘﺭ ﺯﺭ ‪ Finish‬ﻟﻴﻅﻬﺭ ﻟﻙ ﺍﻟﺘﻘﺭﻴﺭ ﻜﻤﺎ ﺘﺭﻯ ﻤﻥ ﺍﻟﺸﻜل ‪:‬‬ ‫‪-١٠‬‬
‫ﻫﺫﺍ ﻫﻭ ﺍﻟﺘﻘﺭﻴﺭ ﺍﻟﺫﻱ ﺃﺸﺄﺘﻪ ﻤﻥ ﺨﻼل ﺍﻟﺨﻁﻭﺍﺕ ﺍﻟﻌﺸﺭ ﺍﻟﻤﺎﻀﻴﺔ‪ .‬ﻫﺫﺍ ﺍﻟﺘﻘﺭﻴﺭ ﻭﻜﻤﺎ‬ ‫‪-١١‬‬
‫ﺘﻼﺤﻅ ﻴﺘﻜﻭﻥ ﻤﻥ ﻋﺩﺓ ﺃﺠﺯﺍﺀ – ﻭ ﺍﻟﻜﻼﻡ ﻴﻨﻁﺒﻕ ﻋﻠﻰ ﺃﻱ ﺘﻘﺭﻴﺭ ‪: -‬‬
‫• ﺭﺃﺱ ﺍﻟﺘﻘﺭﻴﺭ ‪ : ReportHeader‬ﺴﻴﻅﻬﺭ ﻫﺫﺍ ﺍﻟﻘﺴﻡ ﻓﻲ ﺃﻋﻠﻰ ﺍﻟﺘﻘﺭﻴﺭ ﻭ ﻴﺤﻭﻱ‬
‫ﻤﻌﻠﻭﻤﺎﺕ ﻻ ﺘﺘﻜﺭﺭ ﺃﺜﻨﺎﺀ ﻋﺭﺽ ﺍﻟﺘﻘﺭﻴﺭ‪ .‬ﻋﺎﺩﺓ ﻤﺎ ﻴﻜﻭﻥ ﺭﺃﺱ ﺍﻟﺘﻘﺭﻴﺭ ﻤﺎ ﻴﺴﻤﻰ‬
‫ﺒﺎﻟﻜﻠﻴﺸﻪ ﻭ ﻓﻴﻪ ﻴﻜﻭﻥ ﺸﻌﺎﺭ ﺍﻟﻤﻨﺸﺄﺓ ﻭ ﺍﺴﻤﻬﺎ ‪.‬‬
‫• ﺭﺃﺱ ﺍﻟﺼﻔﺤﺔ ‪ : Page Header‬ﻜﺫﻟﻙ ﻴﺤﻭﻱ ﻤﻌﻠﻭﻤﺎﺕ ﻻ ﺘﺘﻜﺭﺭ ﻋﻠﻰ ﻤﺴﺘﻭﻯ‬
‫ﺍﻟﺼﻔﺤﺔ‪ ،‬ﻓﻲ ﺍﻟﻐﺎﻟﺏ ﻴﺤﻭﻱ ﺍﺴﻤﺎﺀ ﺍﻟﺤﻘﻭل ﺍﻟﻤﻌﺭﻭﻀﺔ ﻓﻲ ﺍﻟﺘﻘﺭﻴﺭ‪.‬‬
‫• ﺍﻟﺘﻔﺎﺼﻴل ‪ :‬ﻴﺤﻭﻱ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﻨﺭﻴﺩ ﻋﺭﻀﻬﺎ ﻓﻲ ﺍﻟﺘﻘﺭﻴﺭ‬
‫• ﺘﺫﻴﻴل ﺍﻟﺘﻘﺭﻴﺭ ‪ :‬ﻴﻅﻬﺭ ﻓﻲ ﺁﺨﺭ ﺼﻔﺤﺔ ﻤﻥ ﺍﻟﺘﻘﺭﻴﺭ ﻴﺤﻭﻱ ﻤﻌﻠﻭﻤﺎﺕ ﻤﺜل ﺍﻟﻤﺠﺎﻤﻴﻊ ﻭ‬
‫ﻤﻠﺨﺼﺎﺕ ﺍﻟﺘﻘﺭﻴﺭ‬
‫• ﺘﺫﻴﻴل ﺍﻟﺼﻔﺤﺔ ‪ :‬ﻴﺤﻭﻱ ﻤﻌﻠﻭﻤﺎﺕ ﺘﻅﻬﺭ ﻓﻲ ﺁﺨﺭ ﻜل ﺼﻔﺤﺔ‪ ،‬ﻋﺎﺩﺓ ﻤﺎ ﺘﻜﻭﻥ ﻫﺫﻩ‬
‫ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻤﺜل ﺭﻗﻡ ﺍﻟﺼﻔﺤﺔ ﻭﻋﺩﺩ ﺍﻟﺼﻔﺤﺎﺕ ﻭ ﺍﻟﺘﺎﺭﻳﺦ‪.‬‬
‫‪-١٢‬اﻟﺨﻄﻮة اﻷﺧﻴﺮة هﻲ ﻋﺮض اﻟﺘﻘﺮﻳﺮ‪ .‬ﻟﻌﺮض اﻟﺘﻘﺮﻳﺮ ﻗﻢ ﺑﺎﻟﺨﻄﻮات اﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ -١‬ﻨﻅﺭﺍ ﻷﻨﻨﺎ ﺴﻭﻑ ﻨﻌﺭﺽ ﺍﻟﺘﻘﺭﻴﺭ ﻤﻥ ﺨﻼل ﻨﻤﻭﺫﺝ ﻟﺫﺍ ﻗﻡ ﺒﺈﻀﺎﻓﺔ ﻨﻤﻭﺫﺝ ﺇﻟﻰ‬
‫ﺍﻟﻤﺸﺭﻭﻉ‬
‫‪ -٢‬ﺃﻀﻑ ﺍﻷﺩﺍﺓ ‪CrystalReportViewer‬‬
‫‪204‬‬
‫ﻭﻫﻲ ﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺼﻨﺩﻭﻕ ﺍﻷﺩﻭﺍﺕ‬
‫‪ -٣‬ﻜﺒﺭ ﻫﺫﻩ ﺍﻷﺩﺍﺓ ﻟﺘﺤﺘل ﺍﻟﻨﻤﻭﺫﺝ ﻜﺎﻤﻼ‬

‫‪ -٤‬ﺍﺫﻫﺏ ﺇﻟﻰ ﺍﻟﺨﺎﺼﻴﺔ ‪ReportSource‬‬
‫ﻭ ﺍﺒﺤﺙ ﻋﻥ ﺍﻟﺘﻘﺭﻴﺭ ﺍﻟﺫﻱ ﺃﻨﺸﺄﺘﻪ ﻗﺒل ﻗﻠﻴل ﻭﻫﻭ‬
‫‪FirstReport.rpt‬‬
‫‪ -٥‬ﻗﻡ ﺒﺘﺸﻐﻴل ﺍﻟﻨﻤﻭﺫﺝ ﻟﻴﻅﻬﺭ ﻟﻙ ﺍﻟﺸﻜل ﺍﻟﺘﺎﻟﻲ‬
‫‪205‬‬
‫ﺒﻨﺎﺀ ﺘﻘﺭﻴﺭ ﺍﻋﺘﻤﺎﺩﺍ ﻋﻠﻰ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ‬

‫ﺒﻔﻀل ﺍﻟﺘﻌﺎﻭﻥ ﺒﻴﻥ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻭ ﻜﺭﻴﺴﺘﺎل ﺭﻴﺒﻭﺭﺕ ﻓﺈﻨﻪ ﺒﺈﻤﻜﺎﻨﻙ ﺃﻥ ﺘﺒﻨﻲ ﺘﻘﺭﻴﺭ ﺒﻨﺎﺀ ﻋﻠﻰ‬
‫ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ‪ .‬ﺘﻭﺠﺩ ﻫﻨﺎﻙ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﺍﻟﻔﻭﺍﺌﺩ ﻻﺴﺘﺨﺩﺍﻡ ﻫﺫﻩ ﺍﻟﻁﺭﻴﻘﺔ ﻤﻨﻬﺎ ﺃﻨﻪ ﺒﻤﺠﺭﺩ ﺃﻥ ﺘﻜﺘﻴﺏ‬
‫ﺍﻟﺨﺒﺭﺓ ﻓﻲ ﺍﻟﺘﻌﺎﻤل ﻤﻊ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﻓﺈﻨﻙ ﻟﻥ ﺘﺤﺘﺎﺝ ﺇﻟﻰ ﺍﻟﺘﻌﻤﻕ ﻓﻲ ﺒﺭﻤﺠﺔ ﺍﻟﺘﻘﺎﺭﻴﺭ‪ .‬ﻓﻌﻠﻰ‬
‫ﺴﺒﻴل ﺍﻟﻤﺜﺎل ﺘﺴﺘﻁﻴﻊ ﺘﺭﺸﻴﺢ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺜﻡ ﻋﺭﺽ ﻨﺘﻴﺠﺔ ﺍﻟﺘﺭﺸﻴﺢ ﻋﻠﻰ ﺘﻘﺭﻴﺭ ﺒﺩﻭﻥ ﺃﻥ‬
‫ﺘﻀﻁﺭ ﺇﻟﻰ ﺍﺴﺘﺨﺩﺍﻡ ﻋﻭﺍﻤل ﻓﻲ ﺍﻟﻜﺭﻴﺴﺘﺎل ﺭﻴﺒﻭﺭﺕ‪ .‬ﺃﺤﺩ ﺍﻟﻁﺭﻕ ﻟﺒﻨﺎﺀ ﺍﻟﺘﻘﺭﻴﺭ ﻤﻥ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ‬
‫ﻫﻲ ﺃﻥ ﺘﺼﻤﻡ ﺍﻟﺘﻘﺭﻴﺭ ﻭ ﺘﺤﺩﺩ ﺍﻟﺠﺩﻭل ﺍﻟﺫﻱ ﺴﻴﻜﻭﻥ ﻤﺼﺩﺭﺍ ﻟﻬﺫﺍ ﺍﻟﺘﻘﺭﻴﺭ ﻭ ﺘﻘﻑ ﻋﻨﺩ ﻫﺫﻩ ﺍﻟﻨﻘﻁﺔ‪،‬‬
‫ﺒﻌﺩ ﺫﻟﻙ ﺘﻘﻭﻡ ﺃﺜﻨﺎﺀ ﺍﻟﺘﻨﻔﻴﺫ ﺒﺘﻌﻴﻴﻥ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ ﺴﺘﻌﺭﺽ ﺒﻴﺎﻨﺎﺘﻬﺎ ﻋﻠﻰ ﺍﻟﺘﻘﺭﻴﺭ‬
‫ﻟﻨﺄﺨﺫ ﺍﻟﻤﺜﺎل ﺍﻟﺘﺎﻟﻲ ﻋﻠﻰ ﻜﻴﻔﻴﺔ ﺒﻨﺎﺀ ﺘﻘﺭﻴﺭ ﻤﻥ ﻤﺠﻤﻭﻋﺔ ﺒﻴﺎﻨﺎﺕ ‪:‬‬
‫‪ -١‬ﻗﻡ ﺒﺈﻀﺎﻓﺔ ﺘﻘﺭﻴﺭ ﻭ ﺃﻋﻁﻪ ﺍﺴﻡ ‪ crPerson‬ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل‪.‬‬
‫‪ -٢‬ﺍﺨﺘﺭ ﻨﻔﺱ ﺍﻻﺨﺘﻴﺎﺭﺍﺕ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﺸﻜل‬
‫‪206‬‬
‫‪ -٣‬ﺴﻭﻑ ﻴﻅﻬﺭ ﻟﻙ ﻋﺩﺓ ﺨﻴﺎﺭﺍﺕ ﻓﻲ ﺍﻟﺠﻬﺔ ﺍﻟﻴﺴﺭ‪ ،‬ﻫﺫﻩ ﺍﻟﺨﻴﺎﺭﺍﺕ ﺘﻤﺜل ﻤﺼﺩﺭ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﻟﺘﻲ‬
‫ﺘﺭﻴﺩ ﺃﻥ ﺘﻌﺭﺽ ﺍﻟﺘﻘﺭﻴﺭ ﻤﻨﻬﺎ‪ ،‬ﺍﺨﺘﺭ ‪ Create New Connection‬ﺜﻡ ‪Access/Excel‬‬
‫ﺜﻡ ﺃﻀﻑ ﺍﺘﺼﺎﻻ ﺒﻘﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺒﻌﺩ ﺫﻟﻙ ﺴﺘﻅﻬﺭ ﻜل ﺍﻟﺠﺩﺍﻭل ﻓﻲ ﻗﺎﻋﺩﺓ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺍﺨﺘﺭ‬
‫ﺠﺩﻭل ﺍﻷﺸﺨﺎﺹ ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل‪ .‬ﺜﻡ ﺍﻨﻘﺭ ‪Finish‬‬
‫‪207‬‬
‫‪ -٤‬ﺴﻭﻑ ﻴﻅﻬﺭ ﻟﻙ ﺍﻟﺸﻜل ﻭ ﻫﻭ ﺍﻟﺘﻘﺭﻴﺭ ﺍﻟﺫﻱ ﻨﺘﺞ ﻤﻥ ﺍﻟﺨﻁﻭﺍﺕ ﺍﻟﺴﺎﺒﻘﺔ‪.‬‬
‫‪ -٥‬ﻗﻡ ﺒﺈﻀﺎﻓﺔ ﺍﻟﺤﻘﻠﻴﻥ ﺍﻟﺫﻱ ﺴﻴﻅﻬﺭ ﻓﻲ ﺍﻟﺘﻘﺭﻴﺭ ﻭﻫﻤﺎ ‪ ID‬ﻭ ‪ .Name‬ﺴﻭﻑ ﺘﻅﻴﻔﻬﻤﺎ ﻤﺭﺓ‬
‫ﻭﺍﺤﺩ ﺍﻟﺘﻔﺎﺼﻴل ﻭﻤﻥ ﺜﻡ ﺴﺘﺘﻡ ﺇﻀﺎﻓﺘﻬﻤﺎ ﺁﻟﻴﺎ ﻓﻲ ﺍﻟﺭﺃﺱ ﻜﻤﺎ ﻴﻅﻬﺭ ﻤﻥ ﺍﻟﺸﻜل‪.‬‬
‫ﻏﻴﺭ ﻜﻠﻤﺔ ‪ Name‬ﻭ ‪ ID‬ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺭﺃﺱ ﺍﻟﺘﻘﺭﻴﺭ ﻟﺘﻜﻭﻥ ﺭﻗﻡ ﺍﻟﻤﻭﻅﻑ ﻭ ﺍﺴﻡ ﺍﻟﻤﻭﻅﻑ‬
‫‪208‬‬
‫ ﺃﻨﺸﺊ ﻨﻤﻭﺫﺝ ﺠﺩﻴﺩ ﻭ ﺃﻀﻑ ﺇﻟﻴﻪ ﺯﺭ ﺃﻤﺭ ﻭ ﻤﺭﺒﻊ ﻨﺹ ﻭ ﻤﺴﺘﻌﺭﺽ ﺘﻘﺎﺭﻴﺭ‬-٦

CrystalReportViewer
‫ ﻟﻤﺴﺘﻌﺭﺽ ﺍﻟﺘﻘﺎﺭﻴﺭ ﻫﻭ ﺍﻟﺘﻘﺭﻴﺭ ﺍﻟﺫﻱ ﻗﻤﺕ‬-ReportSource– ‫ﻗﻡ ﺒﺠﻌل ﻤﺼﺩﺭ ﺍﻟﺘﻘﺭﻴﺭ‬
.crPerson ‫ﺒﺈﻨﺸﺎﺌﻪ ﻗﺒل ﻗﻠﻴل ﻭﻩ‬
: ‫ ﺍﻨﻘﺭ ﻤﺯﺩﻭﺝ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ ﻭ ﺃﻀﻑ ﺍﻟﻜﻭﺩ ﺍﻟﺘﺎﻟﻲ‬-٧
Dim sql As String
sql = "select id,name from person where name Like '" &
txtEmpName.Text & "%'"
Dim myds As New DataSet()
myds.Clear()
Try
Dim Adapter As New OleDb.OleDbDataAdapter(sql, con)
Adapter.Fill(myDs, "Person")
If myds.Tables("Person").Rows.Count >= 1 Then
MessageBox.Show(myds.Tables("Person").Rows.Count)
Dim rpt As New crPerson()
rpt.SetDataSource(myds)
CrystalReportViewer1.Zoom(20%)
CrystalReportViewer1.ReportSource = rpt
CrystalReportViewer1.RefreshReport()
End If
Catch err As System.Exception
MsgBox(err.Message)
End Try
: ‫ﺍﻟﺸﺭﺡ‬
‫ ﺴﻭﻑ ﻴﻘﻭﻡ ﺍﻟﻤﺴﺘﺨﺩﻡ ﺒﺈﺩﺨﺎل ﺍﺴﻡ ﺃﻭ ﺠﺯﺀ ﻤﻨﻪ ﻓﻲ ﻤﺭﺒﻊ ﺍﻟﻨﺹ ﻭﻋﻨﺩ ﺍﻟﻨﻘﺭ ﻋﻠﻰ ﺯﺭ ﺍﻷﻤﺭ‬-١
‫ﺴﻭﻑ ﻴﺘﻡ ﺍﻟﺒﺤﺙ ﻋﻥ ﻫﺫﺍ ﺍﻻﺴﻡ ﻓﻲ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ ﺜﻡ ﻋﺭﺽ ﺍﻟﺘﻘﺭﻴﺭ ﺒﻨﺎﺀ ﻋﻠﻰ‬
‫ ﺍﻨﻅﺭ ﺍﻟﺸﻜل‬.‫ﻤﺠﻤﻭﻋﺔ ﺍﻟﺒﻴﺎﻨﺎﺕ‬
209

مقدمة عامة عن بيئة الدوت نت

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

مقدمة عامة عن بيئة الدوت نت

Uploaded by

Copyright:

Available Formats

‫اﻋﺪاد ﺧﺎﻟﺪ اﻟﺠﺪﻳﻊ ‪kal_judaia@hotmail.

‫ﻤﻘﺩﻤﺔ ﻋﺎﻤﺔ ﻋﻥ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‬

‫ﺃﻭﻻ ‪ :‬ﺍﻟﺒﻴﺌﺔ ﺍﻟﻤﺘﺼﻠﺔ‬

‫ﺜﺎﻨﻴﺎ ‪ :‬ﺍﻟﺒﻴﺌﺔ ﺍﻟﻤﻨﻔﺼﻠﺔ‬

‫ﻨﻤﺎﺫﺝ ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﻗﻭﺍﻋﺩ ﺍﻟﺒﻴﺎﻨﺎﺕ ‪:‬‬

‫ﺍﻟﻌﻴﻭﺏ ‪:‬‬ ‫•‬

‫ﻃﺒﻘﺔ ﻗﻮاﻋﺪ اﻟﻌﻤﻞ‬ ‫ﻃﺒﻘﺔ اﻟﺒﻴﺎﻧﺎت‬

‫‪ .D‬ﻨﻤﻭﺫﺝ ﺍﻟﻁﺒﻘﺎﺕ ﺍﻟﻤﺘﻌﺩﺩﺓ‬

‫ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‬

: ‫ﻴﻤﻜﻥ ﺘﻘﺴﻴﻤﻬﺎ ﺇﻟﻰ ﺜﻼﺜﺔ ﻋﻨﺎﺼﺭ‬

‫ ﺇﻁﺎﺭ ﺍﻟﻌﻤل ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‬: ٢-١ ‫ﺸﻜل‬

‫‪ .I‬ﺍﻟﺘﺸﻐﻴل ﺍﻟﻤﺸﺘﺭﻙ ﻟﻠﻐﺎﺕ )‪(CLR‬‬

‫‪ .II‬ﺍﻟﻤﻭﺍﺼﻔﺎﺕ ﺍﻟﻤﺸﺘﺭﻜﺔ ﻟﻠﻐﺎﺕ ‪CLS‬‬

‫ﺍﻟﻜﻭﺩ ﺍﻟﻤﺩﺍﺭ ﻭ ﺍﻟﻜﻭﺩ ﻏﻴﺭ ﺍﻟﻤﺩﺍﺭ‬

‫ﺍﻟﻠﻐﺔ ﺍﻟﻭﺴﻁﻴﺔ ﻟﻤﻴﻜﺭﻭﺴﻭﻓﺕ‬

‫ﺷﻜﻞ ‪ : ٣ -١‬أﺳﻠﻮب إﻧﺘﺎج اﻟﻜﻮد ﻓﻲ ﺑﻴﺌﺔ اﻟﺪوت ﻧﺖ‬

‫ﺍﻟﻤﺅﻟﻑ ﻓﻲ ﺍﻟﻭﻗﺕ ﺍﻟﻤﺤﺩﺩ ‪JIT‬‬

‫ﺃﺴﻤﺎﺀ ﺍﻻﻤﺘﺩﺍﺩﺍﺕ ‪NameSpaces‬‬

‫ﻁﺭﻕ ﺇﻀﺎﻓﺔ ﻤﺭﺠﻊ ﺇﻟﻰ ﻓﻀﺎﺀﺍﺕ ﺍﻷﺴﻤﺎﺀ‬

‫ﺸﻜل ‪ : ٤ -١‬ﺇﻀﺎﻓﺔ ﻤﺭﺠﻊ‬

‫‪ .II‬ﺍﻨﻘﺭ ﻋﻠﻰ ‪ Add Refrence‬ﻟﻴﻅﻬﺭ ﻟﻙ ﺍﻟﺸﻜل )‪(٥-١‬‬

‫ﺸﻜل ‪ : ٦ -١‬ﺍﺨﺘﻴﺎﺭ ﺍﻟﻤﺭﺠﻊ‬

‫ﺍﻟﺠﺩﻭل ﺍﻟﺘﺎﻟﻲ ﻴﻭﻀﺢ ﺒﻌﺽ ﺍﻻﻤﺘﺩﺍﺩﺍﺕ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻭ ﻓﻭﺍﺌﺩﻫﺎ‬

‫ﻤﻘﺩﻤﺔ ﻟﺒﻨﺎﺀ ﺘﻁﺒﻴﻘﺎﺕ ﺍﻟﻭﻨﺩﻭﺯ‬

‫ﺸﻜل ‪ :١-٢‬ﺘﺸﻐﻴل ﻓﻴﺠﻭﺍل ﺴﺘﻭﺩﻴﻭ ﺩﻭﺕ ﻨﺕ‬

‫ﺘﺘﻜﻭﻥ ﻫﺫﻩ ﺍﻟﺼﻔﺤﺔ ﻤﻥ ﺠﺯﺃﻴﻥ ﻫﻤﺎ ‪:‬‬

‫‪ -١‬ﺍﻟﺠﺯﺀ ﺍﻷﻭﺴﻁ ‪ :‬ﻭﻴﺤﻭﻱ ﻨﻭﻋﻴﻥ ﻤﻥ ﺍﻟﻤﻌﻠﻭﻤﺎﺕ ﻭﻫﻲ ‪:‬‬

‫‪ .II‬ﺍﻟﺒﺤﺙ ﻓﻲ ﺍﻟﻤﺸﺎﺭﻴﻊ‪ :‬ﻭﻫﻲ ﻁﺭﻴﻘﺔ ﺴﺭﻴﻌﺔ ﻟﻠﺒﺤﺙ ﻋﻥ ﻤﺴﺎﻋﺩﺓ ﻓﻲ ﺠﻤﻴﻊ ﺍﻟﻤﺸﺎﺭﻴﻊ‬

‫ﺸﻜل ‪ : ٤ -٢‬ﺍﻟﺒﺤﺙ ﻓﻲ ﺍﻟﻤﺸﺎﺭﻴﻊ‬

‫ﺍﻟﻤﻠﻑ ﺍﻟﺸﺨﺼﻲ ‪My Profile‬‬

‫ﺸﻜل ‪ : ٥-٢‬ﺍﻟﻤﻠﻑ ﺍﻟﺸﺨﺼﻲ‬

‫ﺃﻨﻭﺍﻉ ﺍﻟﻤﺸﺎﺭﻴﻊ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‬

‫ﺘﺘﻤﻜﻥ ﻤﻥ ﺒﻴﻌﻬﺎ ﺇﺫﺍ ﻜﺎﻨﺕ ﺃﺩﺍﺓ ﺫﺍﺕ ﻗﻴﻤﺔ‪.‬‬

‫ﺇﻨﺸﺎﺀ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ‬

‫ﺃﻴﻥ ﺘﻨﺸﺄ ﺍﻟﻤﺸﺎﺭﻴﻊ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ﻭﻜﻴﻑ ﻴﺘﻡ ﺫﻟﻙ ؟‬

‫ﺸﻜل ‪ : ٧ -٢‬ﻜﻴﻑ ﺘﻨﺸﺊ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ‬

‫ﺸﻜل ‪ : ٨ -٢‬ﺨﻴﺎﺭﺍﺕ ﺇﻨﺸﺎﺀ ﻤﺸﺭﻭﻉ ﺠﺩﻴﺩ‬

‫ﻤﺎ ﺍﻟﺫﻱ ﺤﺩﺙ ؟‬

‫ﺍﻟﺘﻌﺭﻑ ﻋﻠﻰ ﻤﻜﻭﻨﺎﺕ ﻓﻴﺠﻭﺍل ﺴﺘﻭﺩﻴﻭ ﺩﻭﺕ ﻨﺕ‬

‫ﻨﺎﻓﺫﺓ ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤﻠﻭل‬

‫ﺸﻜل‪ : ٩ -٢‬ﻤﺴﺘﻜﺸﻑ ﺍﻟﺤل‬

‫ﺸﻜل ‪ : ١١-٢‬ﺃﻨﻭﺍﻉ ﺍﻟﻌﻨﺎﺼﺭ ﺍﻟﺘﻲ ﻴﻤﻜﻥ ﺇﻀﺎﻓﺘﻬﺎ ﻟﻠﻤﺸﺭﻭﻉ‬

‫ﺸﻜل ‪:١٤ -٢‬ﺼﻨﺩﻭﻕ ﺍﻷﺩﻭﺍﺕ‬

‫ﻭﻹﻀﺎﻓﺔ ﺸﺭﻴﻁ ﺠﺩﻴﺩ –‪ -Tab‬ﻗﻡ ﺒﺎﻟﺘﺎﻟﻲ ‪:‬‬

‫ﺸﻜل ‪ : ١٥-٢‬ﺇﻀﺎﻓﺔ ﺸﺭﻴﻁ ﺠﺩﻴﺩ ﺇﻟﻰ ﺼﻨﺩﻭﻕ ﺍﻷﺩﻭﺍﺕ‬

‫ﻭﻴﺤﺘﻭﻱ ﺼﻨﺩﻭﻕ ﺍﻷﺩﻭﺍﺕ ﻋﻠﻰ ﺍﻷﺸﺭﻁﺔ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬

‫ﺘﻘﺎﺭﻴﺭ ﻜﺭﻴﺴﺘﺎل ‪:Crystal Reports‬‬

‫"ﻨﻤﺎﺫﺝ ﺍﻟﻭﻴﻨﺩﻭﺯ" ‪:Windows Forms‬‬

‫"ﻨﻤﺎﺫﺝ ﺍﻹﻨﺘﺭﻨﺕ" ‪:Web Forms‬‬

‫ﺘﺴﺘﻁﻴﻊ ﻜﺘﺎﺒﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻤﻥ ﺨﻼل ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ )ﺍﻟﺸﻔﺭﺍﺕ(‪.‬‬

‫ﺸﻜل ‪ : ١٧ -٢‬ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ ﻤﻥ ﺨﻼل‬

‫ﺸﻜل ‪ : ١٨ -٢‬ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ ﻤﻥ ﺍﻟﻨﻤﻭﺫﺝ‬

‫ﺍﻟﻜﻭﺩ ﺍﻟﻤﻨﺘﺞ ﻤﻥ‬

‫ﺏ ـ ﻤﻤﻴﺯﺍﺕ ﻤﺤﺭﺭ ﺍﻟﻜﻭﺩ ﻓﻲ ﺒﻴﺌﺔ ﺍﻟﺩﻭﺕ ﻨﺕ ‪:‬‬

‫ﺸﻜل ‪ : ٢٠-٢‬ﻁﺭﻴﻘﺔ ﺩﻗﻴﻘﺔ ﻟﺘﻅﻠﻴل ﺍﻟﻜﻭﺩ‬

‫ﺃ ـ ﻜﻴﻑ ﺘﻌﻴﻥ ﺨﺼﺎﺌﺹ ﺃﺩﺍﺓ‬

‫ﺸﻜل ‪ : ٢١ -٢‬ﺍﻟﻭﺼﻭل ﺇﻟﻰ ﺨﺼﺎﺌﺹ ﺃﺩﺍﺓ ﻤﺎ‬

‫ﺷﻜﻞ ‪ : ٢٢-٢‬ﺃﻗﺴﺎﻡ ﻧﺎﻓﺬﺓ ﺍﳋﺼﺎﺋﺺ‬

‫‪ -٣‬ﺍﻟﻀﻐﻁ ﻋﻠﻰ ﺯﺭ ‪.F4‬‬

‫ﺏ ـ ﻁﺭﻕ ﻋﺭﺽ ﺘﺭﺘﻴﺏ ﺍﻟﺨﺼﺎﺌﺹ ‪:‬‬

‫ﺸﻜل ‪ : ٢٣ -٢‬ﺍﻟﻌﺭﺽ ﺍﻟﺘﺼﻨﻴﻔﻲ‬

‫ﻜﻴﻑ ﺘﺼل ﺇﻟﻰ ﺍﻟﺤﺩﺙ ﻟﻜﺘﺎﺒﺔ ﺍﻟﻜﻭﺩ‬

‫ﺷﻜﻞ ‪ : ٢٦-٢‬ﻃﺮﻳﻘﺔ ﺍﻟﻮﺻﻮﻝ ﳊﺪﺙ ﻣﺎ‪.‬‬

‫ﻴﻤﻜﻨﻨﺎ ﺘﻘﺴﻴﻡ ﻫﺫﻩ ﺍﻟﺸﺎﺸﺔ ﺇﻟﻰ ﺜﻼﺜﺔ ﺃﻗﺴﺎﻡ ‪:‬‬