You are on page 1of 65

‫ﺗﻮاﺑﻊ ‪Visual Basic.

NET‬‬
‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬
‫آﺘﺎب اﻟﻜﺘﺮوﻧﻴﻜﻲ ﺁﻣﻮزﺷﻲ ‪ -‬آﺎرﺑﺮدي ﻓﺎرﺳﻲ ﺗﻮاﺑﻊ ‪VB.NET‬‬

‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬

‫‪١‬‬

‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬

‫درﺑﺎرﻩ‬

‫آﺘﺎب…‬

‫ﻧﺎم آﺘﺎب‬

‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬

‫ﻧﻮﻳﺴﻨﺪﻩ‬

‫ﺑﻬﺮوز راد‬

‫ﺗﺤﺼﻴﻼت‬

‫داﻧﺸﺠﻮي آﺎﻣﭙﻴﻮﺗﺮ‬

‫ﺗﺎرﻳﺦ ﺗﺎﻟﻴﻒ‬
‫ﺗﻌﺪاد‬
‫ﺻﻔﺤﺎت‬

‫زﻣﺴﺘﺎن ‪١٣٨٢‬‬
‫‪ ٦٥‬ﺻﻔﺤﻪ‬

‫ﺗﻮﺟﻪ‪ :‬اﺳﺘﻔﺎدﻩ از ﻣﻄﺎﻟﺐ اﻳﻦ آﺘﺎب ﺑﺎ ذآﺮ ﻧﺎم ﻣﺆﻟﻒ ﺑﻼﻣﺎﻧﻊ اﺳﺖ‪.‬‬

‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬

‫‪٢‬‬

‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬

‫ﻣﻘﺪﻣﻪ‪:‬‬
‫ﺳﭙﺲ ﺧﺪاي را آﻪ در آﻨﺎر ﻧﻌﻤﺎت ﺑﻴﻜﺮان ﺧﻮد‪ ،‬ﺗﻮﻓﻴﻖ اراﺋﻪ اﻳﻦ آﺘﺎب ﺁﻣﻮزﺷﻲ را ﺑـﻪ دوﺳـﺘﺪاران‬
‫زﺑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ‪ Visual Basic.NET‬ﻋﻨﺎﻳﺖ ﻓﺮﻣﻮد‪.‬‬
‫در ﺑﺮاﺑﺮ اﻧﺒﻮﻩ آﺘﺎب هﺎي اﻟﻜﺘﺮوﻧﻴﻜﻲ ﺁﻣﻮزﺷﻲ اﻧﮕﻠﻴﺴﻲ زﺑﺎن در ﻣﻮرد زﺑﺎن هﺎي ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳـﺴﻲ‪،‬‬
‫آﻤﺒﻮد آﺘﺎب هﺎي ﻓﺎرﺳﻲ در آﺸﻮر ﻣﺎ ﺑﻪ ﺷﺪت اﺣﺴﺎس ﻣﻲ ﺷﻮد‪.‬‬
‫از ﺁن ﻣﻬﻢ ﺗﺮ‪ ،‬آﺘﺎﺑﻲ آﻪ ﺑﺮ روي ﻳﻚ ﻗﺴﻤﺖ از ﻳﻚ زﺑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺗﻤﺮآﺰ داﺷﺘﻪ و ﺑـﻪ ﻧﺤـﻮي‬
‫ﺷﺎﻳﺴﺘﻪ و ﺑﻪ ﮔﻮﻧﻪ اي ﺳﺎدﻩ ﺑﻪ ﺗﻮﺿﻴﺢ ﻣﺒﺤﺚ ﺑﭙﺮدازد‪ ،‬ﺑﻪ ﻧﺪرت دﻳﺪﻩ ﺷﺪﻩ اﺳﺖ‪.‬‬
‫از اﻳﻦ رو ﺑﺮ ﺁن ﺷﺪم ﺗﺎ ﺑﺎ اراﺋﻪ اﻳﻦ آﺘﺎب اﻟﻜﺘﺮوﻧﻴﻜﻲ ﺁﻣﻮزﺷﻲ ‪ -‬آﺎرﺑﺮدي‪ ،‬ﻣﻬﻤﺘﺮﻳﻦ ﺗﻮاﺑﻊ ﻣﻮﺟـﻮد‬
‫در زﺑﺎن ‪ VB.NET‬را آﻪ اآﺜﺮا ﺑﺎ زﺑﺎن ‪ VB.6.0‬ﻣﺸﺘﺮك هﺴﺘﻨﺪ‪ ،‬ﺑﻪ ﺻﻮرت دﺳـﺘﻪ ﺑﻨـﺪي ﺷـﺪﻩ و ﺑـﻪ‬
‫ﻃﻮر آﺎﻣﻞ و ﺑﺎ ﺟﺰﺋﻴﺎت آﺎﻣﻞ ﺗﺮ‪ ،‬ﺑﺎ زﺑﺎﻧﻲ ﺳﺎدﻩ و اراﺋﻪ ﻣﺜﺎل هـﺎي ﻣﺘﻌـﺪد ﺟﻬـﺖ ﻳـﺎدﮔﻴﺮي و ﻓﻬـﻢ‬
‫ﺑﻬﺘﺮ‪ ،‬ﺑﻪ دوﺳﺘﺪاران اﻳﻦ زﺑﺎن ﻗﺪرﺗﻤﻨﺪ اراﺋﻪ آﻨﻢ‪.‬‬
‫از ﺁﻧﺠﺎ آﻪ هﻴﭻ ﻧﻮﺷﺘﻪ اي ﺑﻪ ﻃﻮر آﺎﻣﻞ ﺧﺎﻟﻲ از ﻧﻘﺺ و اﻳﺮاد ﻧﻴـﺴﺖ‪ ،‬ﻟـﺬا از ﺗﻤـﺎﻣﻲ ﺧﻮاﻧﻨـﺪﮔﺎن‬
‫ﮔﺮاﻣﻲ ﺧﻮاهﺸﻤﻨﺪم اﺷﺘﺒﺎهﺎت آﺘﺎب را ﺑﻪ ﻃـﻮر ﻣـﺴﺘﻘﻴﻢ ﺑـﺎ ﺑﻨـﺪﻩ از ﻃﺮﻳـﻖ اﻳﻤﻴـﻞ زﻳـﺮ در ﻣﻴـﺎن‬
‫ﺑﮕﺬارﻧﺪ‪.‬‬
‫اﻣﻴﺪ اﺳﺖ آﻪ ﺑﺎ اﻳﻦ آﺎر آﻮﭼﻚ‪ ،‬ﮔﺎﻣﻲ در ﺟﻬﺖ اﻓﺰاﻳﺶ داﻧﺎﻳﻲ و ﺳﻄﺢ ﻋﻠﻤﻲ دوﺳـﺘﺪاران اﻳـﻦ‬
‫زﺑﺎن ﺑﺮداﺷﺘﻪ ﺷﻮد‪.‬‬
‫ﺑﻪ اﻣﻴﺪ ﻣﻮﻓﻘﻴﺖ روز اﻓﺰون‪.‬‬
‫ﺑﻬﺮوز راد‬
‫زﻣﺴﺘﺎن ‪١٣٨٢‬‬
‫‪behrouz.rad@gmail.com‬‬

‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬

‫‪٣‬‬

‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬

‫ﻧﻜﺎت ﻣﻬﻢ‪:‬‬ ‫‪ (١‬اآﺜــﺮ ﺗﻮاﺑــﻊ ‪ ،VB.‬‬ ‫ﺗﻨﻬﺎ ﺁرﮔﻮﻣﺎن اﺟﺒﺎري در اﻳﻦ ﺗﺎﺑﻊ‪ ،‬اوﻟﻴﻦ ﺁرﮔﻮﻣﺎن ﻳﻌﻨﻲ ‪ String‬ﻣﻲ ﺑﺎﺷﺪ آﻪ رﺷـﺘﻪ اي را ﺗﻌﻴـﻴﻦ‬ ‫ﻣﻲ آﻨﺪ آﻪ آﺎراآﺘﺮهﺎ ﺑﺎﻳﺪ از ﺁن اﺳﺘﺨﺮاج ﺷﻮﻧﺪ‪.NET‬‬ ‫‪٤‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .0‬ﻃـﻮل ﻳـﻚ رﺷـﺘﻪ را ﺑﺮﮔـﺸﺖ ﻣـﻲ دهـﺪ اﻣـﺎ در ‪VB.‬‬ ‫‪ (٤‬ﺁرﮔﻮﻣﺎن هﺎي اﺧﺘﻴﺎري داﺧﻞ آﺮوﺷﻪ ﻗﺮار دارﻧﺪ‪.‬‬ ‫ﻓﺮﺿﺎ اﮔﺮ ﻣﺘﻐﻴﺮ ‪ StrVar‬ﺑﻪ ﻋﻨﻮان ﻳﻚ ﻣﺘﻐﻴﺮ رﺷﺘﻪ اي ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﺑﺎﺷﺪ‪ ،‬ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴـﺪ ﻃـﻮل‬ ‫ﺁن را ﺑﺎ اﺳﺘﻔﺎدﻩ از ﻣﺘﺪ ‪ Length‬اﻳﻦ ﻣﺘﻐﻴﺮ ﺑﻪ دﺳﺖ ﺁورﻳﺪ‪:‬‬ ‫” ‪Dim strVar As String =“a short string‬‬ ‫)”‪Console.length‬‬ ‫ﻣﺤــﻞ ﺷــﺮوع آﺎراآﺘﺮهــﺎﻳﻲ آــﻪ ﺑﺎﻳــﺪ اﺳــﺘﺨﺮاج ﺷــﻮﻧﺪ ﺑــﻪ وﺳــﻴﻠﻪ ﺁرﮔﻮﻣــﺎن ‪ Start‬و ﺗﻌــﺪاد‬ ‫آﺎراآﺘﺮهﺎﻳﻲ آﻪ ﺑﺎﻳﺪ اﺳﺘﺨﺮاج ﺷﻮﻧﺪ را ﺁرﮔﻮﻣﺎن ‪ length‬ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ‪.WriteLine(“The string contains “ & Len(strVar) & “characters‬‬ ‫‪ (٢‬در ‪ VB.‬‬ ‫هﻤﺎﻧﮕﻮﻧﻪ آﻪ ﻣﻼﺣﻈﻪ ﻣﻲ ﺷﻮد ﺁرﮔﻮﻣﺎن ‪ start‬ﻳـﻚ ﺁرﮔﻮﻣـﺎن اﺧﺘﻴـﺎري ﺑـﻮدﻩ و ﭼﻨﺎﻧﭽـﻪ اﺳـﺘﻔﺎدﻩ‬ ‫ﻧﺸﻮد ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﻣﺤﻞ ﺷﺮوع اﺳﺘﺨﺮاج آﺎراآﺘﺮهﺎ از اﺑﺘﺪا ﻳﻌﻨـﻲ اوﻟـﻴﻦ آـﺎراآﺘﺮ رﺷـﺘﻪ در‬ ‫ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد‪.6.‬‬ ‫ﺑـﻪ ﻋﻨـﻮان ﻣﺜـﺎل ﺗـﺎﺑﻊ )(‪ Len‬در ‪ VB.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬ﺷــﺒﻴﻪ ﺑــﻪ ﺗﻮاﺑــﻊ ﻣﻮﺟــﻮد در ‪ VB.‬‬ ‫‪ (٣‬اﮔــﺮ ﺷــﻤﺎ ﻳﻜــﻲ از ﺁرﮔﻮﻣــﺎن هــﺎي اﺧﺘﻴــﺎري را ﺣــﺬف آﻨﻴــﺪ‪ ،‬ﺑﺎﻳــﺪ ﺑــﻪ ﺟــﺎي ﺁن از آــﺎراآﺘﺮ آﺎﻣــﺎ‬ ‫اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.‬‬ ‫اﮔﺮ ﺁرﮔﻮﻣﺎن ‪ length‬اﺳﺘﻔﺎدﻩ ﻧﺸﻮد‪ ،‬از ﻣﻜﺎن ﻣﺸﺨﺺ ﺷﺪﻩ ﺗﺎ ﺑﻪ اﻧﺘﻬﺎي رﺷـﺘﻪ اﺳـﺘﺨﺮاج ﻣـﻲ‬ ‫ﺷﻮﻧﺪ‪.WriteLine(“The string contains“ & strVar.6.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺷﻜﻞ آﻠﻲ ﺗـﺎﺑﻊ )(‪ Mid‬آـﻪ ﺗﻌـﺪادي از آﺎراآﺘﺮهـﺎي ﻳـﻚ رﺷـﺘﻪ را از ﺁن اﺳـﺘﺨﺮاج‬ ‫ﻣﻲ آﻨﺪ ﺑﻪ ﺻﻮرت زﻳﺮ اﺳﺖ‪:‬‬ ‫] ‪newString =Mid(string [.0‬هــﺴﺘﻨﺪ و ﺗﻨﻬــﺎ در ﺑﺮﺧــﻲ ﻣــﻮارد‪،‬‬ ‫ﺗﻐﻴﻴﺮاﺗﻲ در ﻧﺤﻮﻩ ي ﻓﺮاﺧﻮاﻧﻲ و اﺣﻴﺎﻧﺎ ﺳﻴﻨﺘﻜﺲ ﺗﺎﺑﻊ وﺟﻮد دارد‪.start ][.Length & “characters‬‬ ‫ﻳﺎ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻃﻮل اﻳﻦ ﻣﺘﻐﻴﺮ رﺷﺘﻪ اي را ﺑﺎ ﻗﺮار دادن ﺁن در ﺁرﮔﻮﻣﺎن ﺗﺎﺑﻊ )(‪ Len‬ﺑـﻪ دﺳـﺖ‬ ‫ﺁورﻳﺪ‪:‬‬ ‫”‪Dim strVar As String =“a short string‬‬ ‫)”‪Console.NET‬‬ ‫ﺷﻤﺎ ﻗﺎدر ﺑﻪ اﻧﺠﺎم اﻳﻦ آﺎر را ﺑﺎ اﺳﺘﻔﺎدﻩ از ﻣﺘﺪ ‪ Length‬ﻣﺘﻐﻴﺮ رﺷﺘﻪ اي هﺴﺘﻴﺪ‪.NET‬ﺗﻮاﺑﻌﻲ هﺴﺘﻨﺪ آﻪ آﺎر ﺗﻘﺮﻳﺒﺎ ﻳﻜﺴﺎﻧﻲ اﻧﺠﺎم ﻣﻲ دهﻨﺪ و اﻳﻦ ﻧﻜﺘﻪ ﺑـﺴﻴﺎر ﻣﻬـﻢ‬ ‫اﺳﺖ آﻪ ﺷﻤﺎ ﺑﻨﺎ ﺑﻪ ﻧﻴﺎز ﺧﻮد ﺗﺸﺨﻴﺺ دهﻴﺪ آﻪ ﺑﺎﻳﺪ از آﺪاﻣﻴﻚ از اﻳﻦ ﺗﻮاﺑﻊ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.

Now().CSng().Dir().Rename().GetSetting().NET ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ‬ .‫ ﺗﻮاﺑﻊ ﺑﺪون ﺁرﮔﻮﻣﺎن هﺴﺘﻨﺪ‬،‫ ﺗﻮاﺑﻌﻲ آﻪ در اﻧﺘﻬﺎي ﺁﻧﻬﺎ ﭘﺮاﻧﺘﺰ وﺟﻮد ﻧﺪارد‬:‫ﺗﻮﺟﻪ‬ :(Input/output) ‫ﺧﺮوﺟﻲ‬/‫ﺗﻮاﺑﻊ ورودي‬ InputBox().Unlock().MonthName().Randomize :(Graphics) ‫ﺗﻮاﺑﻊ ﮔﺮاﻓﻴﻜﻲ‬ QBColor().StrReverse().Split().FormatCurrency().Hex().InStrRev().TypeName().CurDir().CDbl().InStr().FileAttr().Trim().Day().CChar().Cos().PrintLine().Option.LSet().FileOpen(). Hour().GetAllSettings().Tan() :(Date and Time) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ ﺗﺎرﻳﺦ و زﻣﺎن ﺳﺮ و آﺎر دارﻧﺪ‬ DateAdd().Write().WeekdayName(). Seek().MsgBox() :(File and Folder Manipulation) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ ﻓﺎﻳﻞ هﺎ و ﭘﻮﺷﻪ هﺎ ﺳﺮ و آﺎر دارﻧﺪ‬ ChDir().DateValue().Int().RSet().WriteLine() :(Random Numbers) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺮاي درﺳﺖ آﺮدن اﻋﺪاد ﺗﺼﺎدﻓﻲ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‬ Rnd().Atan().Left().UCase() :(Data Formatting) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ دادﻩ هﺎ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‬ Format().CInt().Fix().Chr().Pow().ChDrive().‫ﺧﻮاهﻨﺪ ﺷﺪ‬ ‫ ﺑﻬﺮوز راد‬:‫ﺑﻪ وﺳﻴﻠﻪ‬ ٥ Visual Basic.Exp().IsDBNull().FileClose().FilePut(). Right().FileCopy().FormatDateTime().Space().Str().StrConv().CDate().Minute().Choose().LTrim().‫ ﺗﻤﺎﻣﻲ ﺗﻮاﺑﻊ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻩ در اﻳﻦ آﺘﺎب ﺑﻪ ﺻـﻮرت دﺳـﺘﻪ ﺑﻨـﺪي ﺷـﺪﻩ ﻟﻴـﺴﺖ ﺷـﺪﻩ‬،‫در زﻳﺮ‬ :‫اﺳﺖ‬ .Lock().StrDup().Oct().FileGet().TimeValue().CStr(). TimeSerial().LCase().FormatNumber().Mid().Shell() :(Miscellaneous) ‫ﺗﻮاﺑﻊ ﻣﺘﻔﺮﻗﻪ‬ Beep.VarType() :(Variable Type Conversion) ‫ﺗﻮاﺑﻊ ﺗﺒﺪﻳﻞ ﻧﻮع ﻣﺘﻐﻴﺮ‬ CBool().Width().IIf().RGB() :(Registry) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ رﺟﻴﺴﺘﺮي ﺳﺮ و آﺎر دارﻧﺪ‬ DeleteSetting().Switch() ‫ هﻤـﺮاﻩ ﺑـﺎ ﻣﺜـﺎل ﺗﻮﺿـﻴﺢ دادﻩ‬،‫ ﺗﻤﺎﻣﻲ ﺗﻮاﺑﻊ ذآﺮ ﺷﺪﻩ ﺑﻪ ﺗﺮﺗﻴﺐ دﺳﺘﻪ ﺑﻨـﺪي و ﺗـﻚ ﺗـﻚ‬،‫در اداﻣﻪ‬ .IsDate().IsNothing(). Input().Round().FormatPercent().Log().CLng().Loc().Filter().CShort().CType() :(String Manipulation) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ رﺷﺘﻪ هﺎ ﺳﺮ و آﺎر دارﻧﺪ‬ Asc().Year() ‫( ﺑــﺮ روي ﻓﺎﻳــﻞ هــﺎ ﻣــﻮرد‬I/O) ‫ﺧﺮوﺟــﻲ‬/‫ﺗــﻮاﺑﻌﻲ آــﻪ ﺟﻬــﺖ اﻧﺠــﺎم ﻋﻤﻠﻴــﺎت ورودي‬ :(File I/O) ‫اﺳﺘﻔﺎدﻩ ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ‬ EOF().StrComp().Reset().Val() :(Math) ‫ﺗﻮاﺑﻊ رﻳﺎﺿﻲ‬ Abs().SaveSetting() :(Application Collaboration) ‫ﺗﻮاﺑﻊ آﺎرﺑﺮدي‬ AppActivate().IsNumeric().MkDir().CObj().Weekday().DateSerial().CallByName().RTrim().Sin().GetAttr().FileDateTime().LOF().RmDir() SetAttr() :(Data Type Identification) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺮاي ﺷﻨﺎﺳﺎﻳﻲ ﻧﻮع دادﻩ هﺎ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‬ IsArray().DatePart().FileLen.Len().Join().ChrW().Replace().Kill.LineInput().Sqrt().Second().Print().AscW().CDec().Month().FreeFile().Mid.CByte().Environ().DateDiff().IsReference.

‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬ ‫‪٦‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﺗﻮاﺑﻊ ﻣﻮﺟﻮد در هﺮ دﺳﺘﻪ ﺑﻪ ﺗﺮﺗﻴﺐ ﺣﺮوف اﻟﻔﺒﺎ ﺗﻮﺿﻴﺢ دادﻩ ﻧـﺸﺪﻩ ﺑﻠﻜـﻪ‬ ‫از ﺁﺳﺎﻧﺘﺮﻳﻦ ﺷﺮوع ﺷﺪﻩ اﺳﺖ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ ﻓﺮﺻﺖ اﻳـﻦ را ﺧـﻮاهﻢ داﺷـﺖ ﺗـﺎ در ﻣﺜـﺎل هـﺎﻳﻲ آـﻪ در‬ ‫ﺗﻮاﺑﻊ دﻳﮕﺮ ﺧﻮاهﻢ زد از ﺗﻮاﺑﻊ دﻳﮕﺮ ﻧﻴﺰ ﺑﺎ هﻤﺪﻳﮕﺮ اﺳﺘﻔﺎدﻩ آﻨﻢ‪.

title ][.‬‬ ‫‪ :Title‬ﻋﻨﻮاﻧﻲ آﻪ در ﻧﻮار ﻋﻨﻮان آﺎدر ﻣﺤﺎورﻩ ﻇﺎهﺮ ﻣﻲ ﺷﻮد‪.‬‬ ‫ﺁرﮔﻮﻣﺎن هﺎي اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺷﺮح زﻳﺮ ﻣﻲ ﺑﺎﺷﻨﺪ‪:‬‬ ‫‪ :prompt‬ﭘﻴﻐﺎﻣﻲ آﻪ در هﻨﮕﺎم ﻇﺎهﺮ ﺷﺪن آﺎدر ﻣﺤﺎورﻩ در ﺁن ﻇﺎهﺮ ﻣﻲ ﺷﻮد‪.‬‬ ‫ﻧﻜﺘﻪ‪ :‬اﻳﻦ واﺣﺪهﺎ ﺑﺮ ﺣﺴﺐ ‪ Twips‬ﻣﻲ ﺑﺎﺷﻨﺪ‪.NET‬‬ ‫‪٧‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﻳﻜﻲ از اﻳﻦ راﻩ هﺎي ارﺗﺒﺎط‪ ،‬اﺳﺘﻔﺎدﻩ از اﻳﻦ دو ﺗﺎﺑﻊ آﺎﻣﻼ آﺎرﺑﺮدي ﻣﻲ ﺑﺎﺷﺪ‪.default ][.‬ﺑـﻪ ﻋﻨـﻮان ﻣﺜـﺎل‬ ‫ﻣﻤﻜﻦ اﺳﺖ آﺎرﺑﺮ ﻣﻘﺪاري را در آﺎدر ﻣﺤﺎورﻩ وارد ﻧﻜﻨﺪ‪.‬‬ ‫ﻧﻜﺘﻪ‪ :‬هﻤﻴﺸﻪ ﻣﻘﺪاري را آﻪ ﺗﻮﺳﻂ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد ﭼﻚ آﻨﻴـﺪ‪ .‬‬ ‫‪ :Xpos. InputBox() :‬‬ ‫ﺑﺮﻧﺎﻣﻪ هﺎي آﺎرﺑﺮدي ﺑﺎﻳﺪ ﺑﻪ ﻧﺤﻮي ﻣﻄﻠﻮب ﺑﺎ اﺳﺘﻔﺎدﻩ از ﻓﺮم هﺎي ﺟـﺬاب و آﺎرﺑﺮﭘـﺴﻨﺪ ﺑـﺎ آـﺎرﺑﺮ‬ ‫ﺧﻮد ارﺗﺒﺎط ﺑﺮﻗﺮار آﻨﻨﺪ‪.ypos‬ﻣﺨﺘﺼﺎت ﮔﻮﺷﻪ ي ﺳﻤﺖ ﭼﭗ و ﺑﺎﻻي اﻳﻦ آﺎدر ﻣﺤـﺎورﻩ از ﺻـﻔﺤﻪ ﻧﻤـﺎﻳﺶ را ﺑـﺎ‬ ‫اﻳﻦ ﻣﻘﺎدﻳﺮ ﺗﻌﻴﻴﻦ آﻨﻴﺪ‪.‬‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ ﺗﺎﺑﻊ هﻤﻴﺸﻪ ﻣﻘﺪاري از ﻧـﻮع ‪ String‬ﻳـﺎ رﺷـﺘﻪ اي اﺳـﺖ‪ ،‬ﺣﺘـﻲ اﮔـﺮ آـﺎرﺑﺮ‬ ‫ﻣﻘﺪاري ﻋﺪدي را وارد آﻨﺪ‪.‬‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ هﺮ ‪ Twips‬ﺑﺮاﺑﺮ ﺑﺎ ﻳﻚ – ﭼﻬﺎرهﺰارو ﭼﻬﺎرﺻﺪو ﭼﻬـﻞ هـﺰارم اﻳـﻨﭻ و ﻳـﻚ –‬ ‫ﭘﺎﻧﺼﺪو ﺷﺼﺖ و هﻔﺖ ﺻﺪم ﺳﺎﻧﺘﻲ ﻣﺘﺮ و ﻳﻚ ﺑﻴﺴﺘﻢ ﻧﻘﻄﻪ )‪ (Point‬اﺳﺖ‪.‬‬ ‫در ﺻﻮرﺗﻲ آﻪ ﻓﻜـﺮ ﻣـﻲ آﻨﻴـﺪ آـﺎرﺑﺮ ﻣﻘـﺪاري از ﻧـﻮع ﺗـﺎرﻳﺦ را وارد ﻣـﻲ آﻨـﺪ ﺑـﺎ اﺳـﺘﻔﺎدﻩ از ﺗـﺎﺑﻊ‬ ‫)(‪ IsDate‬ﻣﻘﺪار ورودي را ﭼﻚ آﻨﻴﺪ و ﺑﻪ هﻤﻴﻦ ﺗﺮﺗﻴﺐ‪ ،‬ﻗﺎﻟﺐ هﺎي دﻳﮕﺮ‪.‬‬ ‫ﻣﺜﺎل زﻳﺮ ﭼﻚ ﻣﻲ آﻨﺪ آﻪ ﻣﻘﺪار ورودي آﺎرﺑﺮ ﺣﺘﻤﺎ ﺗﺎرﻳﺦ ﺑﺎﺷﺪ‪:‬‬ ‫)” ‪BDay =InputBox(“Please enter your birth date‬‬ ‫‪If IsDate(BDay) Then‬‬ ‫)”‪MsgBox(“Yes.‬‬ ‫ﺗﻮﺻﻴﻪ‪ :‬اﮔﺮ ﻗﺼﺪ ﺗﺴﺮﻳﻊ در ﺗﺼﻤﻴﻢ ﮔﻴـﺮي آـﺎرﺑﺮ در وارد آـﺮدن ﻣﻘـﺪار ورودي را دارﻳـﺪ‪ ،‬ﻣﻘـﺪاري را‬ ‫ﺣﺘﻤﺎ در اﻳﻦ ﻗﺴﻤﺖ ذآﺮ آﻨﻴﺪ‪.‬‬ ‫ﺗﻮﺟﻪ‪ :‬اﮔﺮ ﺷﻤﺎ از ذآﺮ اﻳﻦ ﺁرﮔﻮﻣـﺎن اﺧﺘﻴـﺎري ﺧـﻮدداري آﻨﻴـﺪ‪ ،‬ﻧـﺎم ﺑﺮﻧﺎﻣـﻪ ﺷـﻤﺎ در اﻳـﻦ ﻗـﺴﻤﺖ‬ ‫ﻧﻤﺎﻳﺶ دادﻩ ﻣﻲ ﺷﻮد‪.‬‬ ‫اﻳﻦ دو ﺗﺎﺑﻊ ﻋﺒﺎرﺗﻨﺪ از‪MsgBox() .‬‬ ‫در ﺻﻮرﺗﻲ آﻪ ﻓﻜﺮ ﻣﻲ آﻨﻴﺪ آﺎرﺑﺮ ﻣﻘﺪاري ﻋﺪدي را در آﺎدر ﻣﺤﺎورﻩ وارد ﻣﻲ آﻨـﺪ ﺑـﺎ اﺳـﺘﻔﺎدﻩ از‬ ‫ﺗﺎﺑﻊ )(‪ IsNumeric‬ﻣﻘﺪار ورودي را ﭼﻚ آﻨﻴﺪ ﺗﺎ ﺣﺘﻤﺎ از اﻋﺪاد ﺗﺸﻜﻴﻞ ﺷﺪﻩ ﺑﺎﺷﺪ‪.‬‬ ‫اﻳﻦ آـﺎدر ﻣﺤـﺎورﻩ ﺗـﺎ زﻣـﺎن ورود اﻃﻼﻋـﺎت از ﻃـﺮف آـﺎرﺑﺮ و آﻠﻴـﻚ دآﻤـﻪ ‪ OK‬ﻳـﺎ ‪ Cancel‬ﺑـﺮ روي‬ ‫ﺻﻔﺤﻪ ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ‪.ypos‬‬ ‫ﺗﺎﺑﻊ ‪ InputBox‬ﺟﻬﺖ ﻧﻤﺎﻳﺶ ﻳﻚ ﺟﻌﺒﻪ ﮔﻔﺘﮕﻮ )‪ (DialogBox‬هﻤﺮاﻩ ﺑﺎ ﻳـﻚ ﭘﻴﻐـﺎم و ﻳـﻚ ﺟﻌﺒـﻪ‬ ‫ﻣﺘﻦ ﺑﻪ آﺎر ﻣﻲ رود‪.‬‬ ‫)] ‪InputBox(prompt [.xpos ][.‫ﺗﻮاﺑﻊ ورودي‪/‬ﺧﺮوﺟﻲ‬ ‫)‪:(Input/output‬‬ ‫وﻳﮋوال ﺑﻴﺴﻴﻚ دو ﺗﺎﺑﻊ اﺳﺎﺳﻲ را ﺟﻬﺖ ﻧﻤﺎﻳﺶ ﻳﺎ درﺧﻮاﺳﺖ اﻃﻼﻋﺎت ﺑﻪ ﻳﺎ از آﺎرﺑﺮ ﻓﺮاهﻢ آﺮدﻩ‬ ‫اﺳﺖ‪. This is a valid birth date‬‬ ‫‪Else‬‬ ‫)”‪MsgBox(“Please try again with a valid birth date‬‬ ‫‪End If‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬‬ ‫ﺳﺎدﻩ ﺗﺮﻳﻦ ﺷﻜﻞ آﺎرﺑﺮد ﺗﺎﺑﻊ )(‪ InputBox‬ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺖ‪:‬‬ ‫)” ‪SSN =InputBox(“Please enter your name and family‬‬ ‫ﻣﺘﻨﻲ را آﻪ آﺎرﺑﺮ در اﻳﻦ آﺎدر ﻣﺤﺎورﻩ وارد ﻣﻲ آﻨﺪ در ﻣﺘﻐﻴﺮ ‪ SSN‬ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ‪.‬‬ ‫‪ :Default‬ﻣﻘﺪار ورودي ﭘﻴﺶ ﻓﺮض آﺎدر ﻣﺤﺎورﻩ آﻪ در ﺟﻌﺒﻪ ﻣﺘﻦ ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ‪.‬‬ ‫ﻧﻜﺘــﻪ‪ :‬اﮔــﺮ ﻧﻴــﺎز دارﻳــﺪ آــﻪ ﻣــﺘﻦ ‪ Prompt‬ﺷــﻤﺎ در ﭼﻨــﺪﻳﻦ ﺧــﻂ ﭼــﺎپ ﺷــﻮد ﺁن را ﺑــﺎ اﺳــﺘﻔﺎدﻩ از‬ ‫آﺎراآﺘﺮهﺎي ﺧﻄﻲ ‪ VbCr‬ﻳﺎ ‪ VbLf‬ﺑﻪ آﺎر ﺑﺒﺮﻳﺪ‪.

‬‬ ‫ﭘﻴﻐﺎم اﻃﻼﻋﺎﺗﻲ را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪.‬‬ ‫ﭘﻴﻐﺎم هﺸﺪار را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪.‬ﻣﻘـﺪار ﭘـﻴﺶ‬ ‫ﻓﺮض(‬ ‫دآﻤﻪ هﺎي ‪ OK‬و ‪ Cancel‬ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ‪.‬‬ ‫دآﻤﻪ هﺎي ‪ Yes‬و ‪ No‬را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪.‬‬ ‫ﭘﻴﻐـﺎﻣﻲ آــﻪ در اﻳـﻦ آــﺎدر ﻣﺤـﺎورﻩ ﻧﻤــﺎﻳﺶ دادﻩ ﺧﻮاهـﺪ ﺷــﺪ ﺑـﻪ ﻋﻨــﻮان اوﻟـﻴﻦ ﺁرﮔﻮﻣــﺎن و ﺑـﺎ ﻧــﺎم‬ ‫‪ Prompt‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد‪.‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻣﻘﺪاري ﻋﺪدي را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ آﻪ ﻣﻌﺮف ﻣﻘﺪار دآﻤﻪ اي اﺳـﺖ آـﻪ آـﺎرﺑﺮ ﺑـﺮ روي‬ ‫ﺁن آﻠﻴﻚ آﺮدﻩ‪.‬‬ ‫ﺳﺎدﻩ ﺗﺮﻳﻦ ﺷﻜﻞ اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺖ‪:‬‬ ‫)”!‪MsgBox(“Your Computer is running out of memory‬‬ ‫اﻳﻦ دﺳﺘﻮر ﻳﻚ ﭘﻴﻐﺎم را در ﻳﻚ آﺎدر ﻣﺤﺎورﻩ هﻤﺮاﻩ ﺑﺎ ﻳﻚ دآﻤﻪ ‪ OK‬ﻧﻤﺎﻳﺶ ﺧﻮاهﺪ داد‪.‬‬ ‫‪٨‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫دآﻤــﻪ هــﺎي ‪ Yes‬و ‪ No‬و ‪ Cancel‬ﻧﻤــﺎﻳﺶ‬ ‫دادﻩ ﺧﻮاهﻨﺪ ﺷﺪ‪.NET‬‬ ‫ﺗﺎ زﻣﺎﻧﻲ آﻪ آﺎرﺑﺮ ﺑﻪ آﺎدر ﻣﺤﺎورﻩ ﺟﻮاﺑﻲ ﻧﺪهﺪ‬ ‫ﻧﻤﻲ ﺗﻮاﻧﺪ ﺑﺮ روي هﻴﭽﻜﺪام از ﻓﺮم هﺎي ﺑﺮﻧﺎﻣﻪ‬ ‫ﺟﺎري ﺳﻮﻳﭻ آﻨﺪ‪.‬‬ ‫ﺗﺎ زﻣﺎﻧﻲ آﻪ آﺎرﺑﺮ ﺑﻪ آﺎدر ﻣﺤﺎورﻩ ﺟﻮاﺑﻲ ﻧﺪهﺪ‬ ‫ﻧﻤﻲ ﺗﻮاﻧﺪ ﺑﻪ هﻴﭻ آﺪام از ﺑﺮﻧﺎﻣﻪ هﺎي در ﺣـﺎل‬ ‫اﺟﺮا ﺳﻮﻳﭻ آﻨﺪ‪.‬‬ ‫ﻣﻘﺎدﻳﺮ ﺁﻳﻜﻮن هﺎ در ﭘﺎراﻣﺘﺮ ‪ buttons‬از ﺗﺎﺑﻊ )(‪MsgBox‬‬ ‫‪ Critical‬ﻳﺎ ‪16‬‬ ‫‪Question‬ﻳﺎ ‪32‬‬ ‫‪ Exclamation‬ﻳﺎ ‪48‬‬ ‫‪Information‬ﻳﺎ ‪64‬‬ ‫ﺁﻳﻜﻮن‬ ‫ﺁﻳﻜﻮن‬ ‫ﺁﻳﻜﻮن‬ ‫ﺁﻳﻜﻮن‬ ‫ﭘﻴﻐﺎم ﺣﺴﺎس را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪.‬‬ ‫ﻋﻼﻣﺖ ﺳﻮال را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪.title‬‬ ‫ﺗﺎﺑﻊ )(‪ ،MsgBox‬ﻳﻚ آﺎدر ﻣﺤﺎورﻩ را هﻤﺮاﻩ ﺑﺎ ﻳﻚ ﭘﻴﻐﺎم ﻧﻤﺎﻳﺶ دادﻩ و ﺗﺎ زﻣـﺎن ﺑـﺴﺘﻪ ﺷـﺪن آـﻪ‬ ‫ﺑﺎ آﻠﻴﻚ آﺎرﺑﺮ ﺑﺮ روي هﺮ ﻳﻚ از دآﻤﻪ هﺎي ﺁن اﻧﺠﺎم ﻣﻲ ﭘﺬﻳﺮد‪ ،‬ﺑﺮ روي ﺻﻔﺤﻪ ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ‪.‬‬ ‫ﺗﺎﺑﻊ )(‪ MsgBox‬هﻤﭽﻨﻴﻦ ﻗﺎدر ﺑﻪ ﻧﻤﺎﻳﺶ دآﻤﻪ هﺎ و ﺁﻳﻜﻮن هﺎﻳﻲ ﻧﻴﺰ در آﺎدر ﻣﺤـﺎورﻩ ﺧـﻮد ﻣـﻲ‬ ‫ﺑﺎﺷﺪ‪.‬‬ ‫دآﻤــﻪ هــﺎي ‪ Retry‬و ‪ Cancel‬را ﻧﻤــﺎﻳﺶ ﻣــﻲ‬ ‫دهﺪ‪.‬‬ ‫ﻣﻘﺎدﻳﺮ ﺷﺮﻃﻲ در ﭘﺎراﻣﺘﺮ ‪ buttons‬از ﺗﺎﺑﻊ )(‪MsgBox‬‬ ‫‪ ApplicationModal‬ﻳﺎ ‪0‬‬ ‫‪ SystemModal‬ﻳﺎ ‪4096‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬‬ ‫ﻣﻘﺎدﻳﺮ زﻳﺮ آﻠﻴﻪ ﻣﻘﺎدﻳﺮي هﺴﺘﻨﺪ آﻪ ﺁرﮔﻮﻣﺎن ‪ buttons‬ﻗﺎدر ﺑﻪ درﻳﺎﻓﺖ ﺁﻧﻬﺎﺳﺖ‪:‬‬ ‫ﻣﻘﺎدﻳﺮ دآﻤﻪ هﺎ در ﭘﺎراﻣﺘﺮ ‪ buttons‬از ﺗﺎﺑﻊ )(‪MsgBox‬‬ ‫‪ OKOnly‬ﻳﺎ ‪0‬‬ ‫‪ OKCancel‬ﻳﺎ ‪1‬‬ ‫‪ AbortRetryIgnore‬ﻳﺎ ‪2‬‬ ‫‪ YesNoCancel‬ﻳﺎ ‪3‬‬ ‫‪ YesNo‬ﻳﺎ ‪4‬‬ ‫‪RetryCancel‬‬ ‫ﺗﻨﻬﺎ دآﻤﻪ ‪ OK‬ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ‪).‫)] ‪MsgBox(prompt [.‬‬ ‫دوﻣــﻴﻦ دآﻤــﻪ را ﺑــﻪ ﻋﻨــﻮان دآﻤــﻪ ﭘــﻴﺶ ﻓــﺮض‬ ‫اﻧﺘﺨﺎب ﻣﻲ آﻨﺪ‪.buttons ][.‬‬ ‫دآﻤـــﻪ هـــﺎي ‪ Abort‬و ‪ Retry‬و ‪Ignore‬‬ ‫ﻧﻤﺎﻳﺶ دادﻩ ﺧﻮاهﻨﺪ ﺷﺪ‪.‬‬ ‫ﻣﻘﺎدﻳﺮ دآﻤﻪ هﺎي ﭘﻴﺶ ﻓﺮض در ﭘﺎراﻣﺘﺮ ‪ buttons‬از ﺗﺎﺑﻊ )(‪MsgBox‬‬ ‫‪ DefaultButton1‬ﻳﺎ ‪0‬‬ ‫‪ DefaultButton2‬ﻳﺎ ‪256‬‬ ‫‪ DefaultButton3‬ﻳﺎ ‪512‬‬ ‫اوﻟــﻴﻦ دآﻤــﻪ را ﺑــﻪ ﻋﻨــﻮان دآﻤــﻪ ﭘــﻴﺶ ﻓــﺮض‬ ‫اﻧﺘﺨﺎب ﻣﻲ آﻨﺪ‪.‬‬ ‫ﺳﻮﻣﻴﻦ دآﻤﻪ را ﺑـﻪ ﻋﻨـﻮان دآﻤـﻪ ﭘـﻴﺶ ﻓـﺮض‬ ‫اﻧﺘﺨﺎب ﻣﻲ آﻨﺪ‪.

‬‬ ‫ﻣﻘﺎدﻳﺮ ﭘﻴﺶ ﻓﺮض دآﻤﻪ هﺎ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﻨﺪ آﻪ آﺪام دآﻤﻪ در هﻨﮕﺎم ﻇـﺎهﺮ ﺷـﺪن آـﺎدر ﻣﺤـﺎورﻩ‬ ‫ﺑﻪ ﻋﻨﻮان دآﻤﻪ ﭘﻴﺶ ﻓﺮض اﻧﺘﺨﺎب ﺷﺪﻩ ﺑﺎﺷﺪ‪ .‫ﻣﻘﺎدﻳﺮ دآﻤﻪ هﺎ ﺑﻪ ﺷﻤﺎ اﻳﻦ اﻣﻜﺎن را ﻣﻲ دهﺪ آﻪ ﺗﻌﻴﻴﻦ آﻨﻴﺪ آﺪاﻣﻴﻚ از دآﻤﻪ هﺎ ﺑـﺮ روي آـﺎدر‬ ‫ﻣﺤﺎورﻩ ﻇﺎهﺮ ﺷﻮد‪.‬‬ ‫در ﻣﺜﺎل ﺑﻌﺪي ﻗﺼﺪ ﻇﺎهﺮ آﺮدن آﺎدر ﻣﺤﺎورﻩ اي ﺑﺎ دآﻤﻪ هﺎي ‪ Yes‬و ‪ No‬هﻤﺮاﻩ ﺑـﺎ ﺁﻳﻜـﻮن ﭘﻴﻐـﺎم‬ ‫ﺣﺴﺎس را دارﻳﻢ‪:‬‬ ‫_‪Res =MsgBox(“Incomplete data.‬‬ ‫ﺗﺎﺑﻊ )(‪ ،MsgBox‬ﻣﻘﺪاري از ﻧﻮع ‪ Integer‬را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ آﻪ ﻣﻌﻴﻦ ﻣﻲ آﻨـﺪ آـﺪام دآﻤـﻪ‬ ‫ﺗﻮﺳﻂ آﺎرﺑﺮ ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ‪ .Would you like to retry?”.‬‬ ‫‪ No‬ﻳﺎ ‪7‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺑﺮاي ﻧﻤﺎﻳﺶ آﺎدر ﻣﺤﺎورﻩ اي ﺑﺎ دآﻤﻪ هﺎي ‪ OK‬و ‪ Cancel‬و ﺁﻳﻜﻮن ﭘﻴﻐﺎم هـﺸﺪار‬ ‫ﺑﻪ ﺻﻮرت زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ‪:‬‬ ‫_‪Res =MsgBox(“This operation may take several minutes”.‬‬ ‫‪ Abort‬ﻳﺎ ‪3‬‬ ‫دآﻤﻪ ‪ Retry‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ‪.‬‬ ‫‪ Yes‬ﻳﺎ ‪6‬‬ ‫دآﻤﻪ ‪ No‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ‪.‬اﻳﻦ روﻳـﺪاد ﻣﻤﻜـﻦ اﺳـﺖ ﺣـﺴﺎس‪ ،‬ﭘﺮﺳـﺸﻲ‪ ،‬هـﺸﺪار و ﻳـﺎ اﻃﻼﻋـﺎﺗﻲ‬ ‫ﺑﺎﺷﺪ‪.‬‬ ‫‪ Ignore‬ﻳﺎ ‪5‬‬ ‫دآﻤﻪ ‪ Yes‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ‪.‬‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﺷﻤﺎ ﻧﻤﻲ ﺗﻮاﻧﻴﺪ ﻳﻚ ﻣﻘﺪار ﻣﻨﺤﺼﺮ ﺑﻪ ﻓﺮد ﺑﺮاي اﻳﻦ ﺁرﮔﻮﻣﺎن ﺗﻌﻴﻴﻦ آﻨﻴﺪ‪.NET‬‬ ‫‪٩‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫)‪MsgBoxStyle.‬‬ ‫ﻣﻘﺎدﻳﺮ ﺁﻳﻜﻮن هﺎ ﻧﻮع ﺁﻳﻜﻮن ﻇﺎهﺮ ﺷﻮﻧﺪﻩ را ﺑﺮاي ﻣﺎ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﻨﺪ‪.‬‬ ‫)‪MsgBoxStyle.‬‬ ‫‪ Cancel‬ﻳﺎ ‪2‬‬ ‫دآﻤﻪ ‪ Abort‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ‪.YesNo +MsgBoxStyle.‬‬ ‫ﻣﻘﺎدﻳﺮ ﺷﺮﻃﻲ ﻧﻴﺰ ﻧﻮع رﻓﺘﺎر آﺎدر ﻣﺤﺎورﻩ را ﺑﻪ ﻋﻜﺲ اﻟﻌﻤﻞ آﺎرﺑﺮ ﻣﺸﺨﺺ ﻣﻲ آﻨﻨﺪ‪.‬‬ ‫‪ OK‬ﻳﺎ ‪1‬‬ ‫دآﻤﻪ ‪ Cancel‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ‪.‬‬ ‫زﻣﺎﻧﻲ آﻪ روﻳﺪادي اﺳﺘﺜﻨﺎﻳﻲ ﻳﺎ ﻏﻴـﺮ ﻋـﺎدي در وﻳﻨـﺪوز رخ دهـﺪ‪ ،‬ﺑـﻪ وﺳـﻴﻠﻪ ﺁﻳﻜـﻮن هـﺎ ﻧـﻮع اﻳـﻦ‬ ‫روﻳﺪاد ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد‪ .OKCancel‬‬ ‫ﻣﻘﺪاري آﻪ ﺗﻮﺳﻂ اﻳﻦ آﺎدر ﻣﺤﺎورﻩ ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﺪ ﺷﺪ‪ ،‬ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ ذآﺮ ﺷﺪﻩ در ﺟﺪول‬ ‫ﺑﺎﻻﺳﺖ آﻪ ﺑﺴﺘﻪ ﺑﻪ اﻧﺘﺨﺎب هﺮ ﻳﻚ از دآﻤﻪ هﺎي ‪ OK‬ﻳﺎ ‪ ،Cancel‬ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ ‪ 1‬ﻳﺎ ‪ 2‬ﺧﻮاهـﺪ‬ ‫ﺑﻮد‪.Critical‬‬ ‫‪If Res =MsgBoxResult.‬‬ ‫‪ Retry‬ﻳﺎ ‪4‬‬ ‫دآﻤﻪ ‪ Ignore‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ‪.‬در ﺻﻮرﺗﻲ آﻪ ﺗﻌﻴﻴﻦ ﻧﺸﻮد اوﻟﻴﻦ دآﻤﻪ از ﺳﻤﺖ‬ ‫ﭼﭗ ﺑﻪ ﻋﻨﻮان دآﻤﻪ ﭘﻴﺶ ﻓﺮض اﻧﺘﺨﺎب ﻣﻲ ﺷﻮد‪.Exclamation +MsgBoxStyle.‬اﻳﻦ ﻣﻘﺎدﻳﺮ در ﺟﺪول زﻳﺮ ﻟﻴﺴﺖ ﺷﺪﻩ اﺳﺖ‪:‬‬ ‫ﻣﻘﺎدﻳﺮي آﻪ ﺗﺎﺑﻊ )(‪ MsgBox‬ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‬ ‫ﺗﻮﺿﻴﺤﺎت‬ ‫ﻣﻘﺪار‬ ‫دآﻤﻪ ‪ OK‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ‪.Yes Then ‘user clicked Yes‬‬ ‫}‪{prompt again‬‬ ‫‪Else ‘user clicked No‬‬ ‫}‪{exit procedure‬‬ ‫‪Endif‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.

‬‬ ‫)‪:GetAttr(pathname‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻣﻘﺪاري را از ﻧﻮع ‪ Integer‬ﺑﺮﮔﺸﺖ ﻣـﻲ دهـﺪ آـﻪ ﻧﻤﺎﻳـﺎﻧﮕﺮ ﺻـﻔﺖ ﻓﺎﻳـﻞ‪ ،‬داﻳﺮآﺘـﻮري ﻳـﺎ‬ ‫ﭘﻮﺷﻪ اي اﺳﺖ آﻪ ﻧﺎم ﺁن در ﺁرﮔﻮﻣﺎن ‪ pathname‬ﺁﻣﺪﻩ اﺳﺖ‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪ ،‬ﺟﻬﺖ ﺗﺸﺨﻴﺺ اﻳﻨﻜﻪ ﻋﺒـﺎرت ﻣـﺎ داراي ﺻـﻔﺖ ﻓﻘـﻂ ﺧﻮاﻧـﺪﻧﻲ اﺳـﺖ ﻳـﺎ ﺧﻴـﺮ ﺑـﻪ‬ ‫ﺻﻮرت زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ‪:‬‬ ‫‪Result =GetAttr(FName) And FileAttribute.‬‬ ‫از ﻋﻤﻠﮕﺮ ‪ OR‬ﻧﻴﺰ ﻣﻲ ﺗﻮاﻧﻴﺪ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.‬‬ ‫در ﻣﺜﺎل زﻳﺮ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﻴﻢ آﻪ ﺁﻳﺎ ﻋﺒﺎرت ﻣﺎ داراي ﺻﻔﺖ ‪ Archive‬اﺳﺖ ﻳﺎ ﺧﻴﺮ‪:‬‬ ‫‪Result =GetAttr(FName)And FileAttribute.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ ﻓﺎﻳﻞ هﺎ و ﭘﻮﺷﻪ هﺎ ﺳﺮ و آﺎر دارﻧﺪ )‪:(File and Folder Manipulation‬‬ ‫ﺗﻮاﺑﻊ زﻳﺮ ﺑﺮﺧﻲ از آﺎرهﺎي ﻣﺪﻳﺮﻳﺘﻲ را در راﺑﻄﻪ ﺑﺎ ﻓﺎﻳﻞ هﺎ و ﭘﻮﺷﻪ هﺎ هﻤﺎﻧﻨﺪ اﻧﺘﻘﺎل و ﺗﻐﻴﻴـﺮ ﻧـﺎم‬ ‫ﻓﺎﻳﻞ هﺎ‪ ،‬اﻳﺠﺎد ﭘﻮﺷﻪ ﺟﺪﻳﺪ‪ ،‬ﺣﺬف ﻓﺎﻳﻞ ﻳﺎ ﭘﻮﺷﻪ و … اﻧﺠﺎم ﻣﻲ دهﻨﺪ‪.‬‬ ‫)‪SetAttr(pathname.Archive‬‬ ‫اﮔﺮ ﻋﺒﺎرت‪ ،‬داراي ﻣﻘﺪار ‪ Archive‬ﺑﺎﺷﺪ‪ ،‬ﻣﻘﺪار ‪ 32 ،Result‬ﺧﻮاهﺪ ﺑﻮد‪.‬‬ ‫اﮔﺮ ﻋﺒﺎرت ﻣﺎ هﺮ دو ﻣﻘﺪار ﻓﻘﻂ ﺧﻮاﻧﺪﻧﻲ و ﺁرﺷﻴﻮ را دارا ﺑﺎﺷﺪ‪ ،‬ﻣﻘـﺪار ‪ ReadOnly‬و ‪Archive‬‬ ‫ﺑﺎ ﻳﻜﺪﻳﮕﺮ ﺟﻤﻊ ﻣﻲ ﺷﻮﻧﺪ‪ ،‬در ﻧﺘﻴﺠﻪ ‪33 ،Result‬ﺧﻮاهﺪ ﺷﺪ‪.‬‬ ‫ﻓﺮﻣﺎن هﺎي زﻳﺮ ﺑﺎ ﻣﺤﺘﻮﻳﺎت ﻓﺎﻳﻞ هﺎ آﺎري ﻧﺪاﺷﺘﻪ و اآﺜﺮا هﻤﺎﻧﻨﺪ ﻓﺮﻣﺎن هﺎي ﻣﺪﻳﺮﻳﺘﻲ ﻓﺎﻳﻞ هـﺎ و‬ ‫ﭘﻮﺷﻪ هﺎي ‪ DOS‬هﺴﺘﻨﺪ‪.attributes‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﺻﻔﺘﻲ را ﺑﺮ روي ﻳﻚ ﻓﺎﻳﻞ ﻗﺮار ﻣﻲ دهﺪ‪.NET‬‬ ‫‪١٠‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،pathname‬ﻣﺴﻴﺮ ﻓﺎﻳﻠﻲ اﺳﺖ آﻪ ﻗﺮار اﺳﺖ ﺻﻔﺖ ﺑﺮ روي ﺁن اﻳﺠﺎد ﺷـﻮد و ﺁرﮔﻮﻣـﺎن‬ ‫‪ attributes‬ﻳﻚ ﻣﻘﺪار ﻋﺪدي اﺳﺖ آﻪ ﺑﺮاي ﺗﻌﻴﻴﻦ ﻧﻮع ﺻـﻔﺖ ﻳـﺎ ﺻـﻔﺖ هـﺎﻳﻲ اﺳـﺖ آـﻪ ﻗـﺮار‬ ‫اﺳﺖ ﺑﺮ روي ﻓﺎﻳﻞ اﻳﺠﺎد ﺷﻮد‪.ReadOnly‬‬ ‫اﮔﺮ ﻋﺒﺎرت ‪ Fname‬داراي ﺻﻔﺖ ﻓﻘـﻂ ﺧﻮاﻧـﺪﻧﻲ ﺑﺎﺷـﺪ‪ ،‬ﻣﻘـﺪار ﺑﺮﮔـﺸﺘﻲ آـﻪ در ﻣﺘﻐﻴـﺮ ‪Result‬‬ ‫ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮد‪ 1 ،‬ﺧﻮاهﺪ ﺑﻮد در ﻏﻴﺮ اﻳﻨـﺼﻮرت ﺑـﺎ ﻓـﺮض اﻳﻨﻜـﻪ ﻋﺒـﺎرت ﻣـﺎ هـﻴﭻ ﺻـﻔﺖ دﻳﮕـﺮي‬ ‫ﻧﺪارد‪ ،‬ﻣﻘﺪار ‪ ،Result‬ﺻﻔﺮ ﺧﻮاهﺪ ﺑﻮد‪.‬‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ اﻳﻦ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮاﻧﺪ ﺑﺮﮔﺸﺖ دهﺪ در زﻳﺮ ﻟﻴﺴﺖ ﺷﺪﻩ اﺳﺖ‪:‬‬ ‫ﻣﻘﺎدﻳﺮي آﻪ ﺗﺎﺑﻊ )(‪ GetAttr‬ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‬ ‫ﺗﻮﺿﻴﺤﺎت‬ ‫ﻣﻘﺪار‬ ‫ﻧﺮﻣﺎل )هﻴﭻ ﺻﻔﺘﻲ ﻧﺪارد(‬ ‫‪ Normal‬ﻳﺎ ‪0‬‬ ‫ﻓﻘﻂ ﺧﻮاﻧﺪﻧﻲ‬ ‫‪ ReadOnly‬ﻳﺎ ‪1‬‬ ‫ﻣﺨﻔﻲ‬ ‫‪ Hidden‬ﻳﺎ ‪2‬‬ ‫ﺳﻴﺴﺘﻤﻲ‬ ‫‪ System‬ﻳﺎ ‪4‬‬ ‫ﺑﺮﭼﺴﺐ دراﻳﻮ‬ ‫‪ Volume‬ﻳﺎ ‪8‬‬ ‫داﻳﺮآﺘﻮري ﻳﺎ ﭘﻮﺷﻪ‬ ‫‪ Directory‬ﻳﺎ ‪16‬‬ ‫ﺁرﺷﻴﻮ )ﻓﺎﻳـﻞ در ﺁﺧـﺮﻳﻦ دﺳﺘﺮﺳـﻲ ﺗﻐﻴﻴـﺮ ﭘﻴـﺪا‬ ‫‪ Archive‬ﻳﺎ ‪32‬‬ ‫آﺮدﻩ اﺳﺖ(‬ ‫ﻧﻜﺎت ﻣﻬﻢ در اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ‪ :‬ﺑﺮاي ﺗﺸﺨﻴﺺ اﻳﻨﻜـﻪ ﻋﺒـﺎرت ﻣـﺎ داراي ﭼـﻪ ﺻـﻔﺖ ﻳـﺎ ﺻـﻔﺎﺗﻲ‬ ‫اﺳﺖ از ﻋﻤﻠﮕﺮ ‪ AND‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪ ).‬‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ ﺁرﮔﻮﻣﺎن ‪ attributes‬ﻣﻲ ﺗﻮاﻧﺪ ﺑﭙﺬﻳﺮد در ﺟﺪول ﺗﺎﺑﻊ )(‪ GetAttr‬ذآﺮ ﺷﺪ‪.‬ﻣﻤﻜﻦ اﺳﺖ ﻋﺒﺎرت داراي ﭼﻨﺪﻳﻦ ﺻﻔﺖ ﺑﺎﺷﺪ(‬ ‫اﮔﺮ ﻋﺒﺎرت ﻣﺎ هﻴﭽﮕﻮﻧﻪ ﺻﻔﺘﻲ ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ‪ ،‬ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ‪ ،‬ﺻﻔﺮ ﺧﻮاهﺪ ﺑﻮد‪.

vbHidden And -vbReadOnly And vbArchive‬‬ ‫اﻳﻦ دﺳﺘﻮر ﺻﻔﺖ هﺎي ﻣﺨﻔﻲ و ﺁرﺷﻴﻮ را ﺑﺮ روي ﻓﺎﻳﻞ ‪ MyFile. GetAttr(file_name) .‬‬ ‫هﻤﭽﻨﻴﻦ ﺷﻤﺎ در اﻳﻦ ﺗﺎﺑﻊ ﻗﺎدر ﺑﻪ اﺳﺘﻔﺎدﻩ از آﺎراآﺘﺮهﺎي ﺟﺎﻧﺸﻴﻨﻲ هﺴﺘﻴﺪ‪ *) .txt‬اﻳﺠﺎد و ﺻﻔﺖ ﻓﻘﻂ ﺧﻮاﻧـﺪﻧﻲ‬ ‫ﺁن را ﺑﺮ ﻣﻲ دارد‪.‬‬ ‫ﺳﻌﻲ آﻨﻴﺪ از اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪:‬‬ ‫‪Try‬‬ ‫)”‪Kill(“C:\Log.Hidden‬‬ ‫‪End If‬‬ ‫در اﻳﻦ ﻣﺜﺎل‪ ،‬اﺑﺘﺪا ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗـﺎﺑﻊ )(‪ GetAttr‬ﭼـﻚ ﻣـﻲ ﺷـﻮد آـﻪ ﻓﺎﻳـﻞ ﻣـﻮرد ﻧﻈـﺮ ﻣـﺎ داراي‬ ‫ﺻﻔﺖ ﻣﺨﻔﻲ اﺳﺖ ﻳﺎ ﺧﻴﺮ‪ ،‬اﮔﺮ داراي ﺻﻔﺖ ﻣﺨﻔﻲ ﺑﺎﺷﺪ ﺻـﻔﺖ ﻣﺨﻔـﻲ ﺁن ﺑـﺎ اﺳـﺘﻔﺎدﻩ از ﺗـﺎﺑﻊ‬ ‫)(‪ SetAttr‬ﺑﺮداﺷﺘﻪ ﻣﻲ ﺷﻮد‪.‬‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ‪ :‬در ﺻﻮرﺗﻲ آﻪ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ FileCopy‬ﻓﺎﻳﻠﻲ را ﺑﻪ ﺳﻄﻞ زﺑﺎﻟﻪ وﻳﻨـﺪوز اﻧﺘﻘـﺎل‬ ‫دهﻴﺪ‪ ،‬ﻓﺎﻳﻞ ﻣﻨﺘﻘﻞ ﺷﺪﻩ در ﭘﻨﺠﺮﻩ ﺳﻄﻞ زﺑﺎﻟﻪ ﻇﺎهﺮ ﺧﻮاهـﺪ ﺷـﺪ اﻣـﺎ ﺷـﻤﺎ ﻗـﺎدر ﺑـﻪ ﺑﺎزﻳـﺎﺑﻲ ﺁن‬ ‫ﻧﺨﻮاهﻴﺪ ﺑﻮد‪.‬‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ در ﺻﻮرﺗﻲ آﻪ ﻳﻚ ﺻﻔﺖ را ﺑﺮاي ﻳﻚ ﻓﺎﻳﻞ ﺗﻌﻴـﻴﻦ ﻣـﻲ آﻨﻴـﺪ ﺻـﻔﺖ ﻳـﺎ ﺻـﻔﺎت‬ ‫ﻗﺒﻠﻲ ﻓﺎﻳﻞ ﺣﺬف ﻣﻲ ﺷﻮﻧﺪ‪.‫ﻧﻜﺎت ﻣﻬﻢ در اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ‪ :‬از ﺁﻧﺠﺎ آﻪ اﻳﻦ ﺗﺎﺑﻊ ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ ﻧﺪارد‪ ،‬ﺁن را در ﻣﺘﻐﻴـﺮ ﻗـﺮار‬ ‫ﻧﺪهﻴﺪ‪. GetAttr(file_name)– FileAttribute.‬‬ ‫هﻤﭽﻨﻴﻦ ﻣﻲ ﺗﻮان ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ MsgBox‬در ﻣﻮرد ﺣﺬف ﺻﻔﺖ ﻓﺎﻳﻞ ﺗﺎﻳﻴﺪ ﮔﺮﻓﺖ‪:‬‬ ‫‪If GetAttr(file_name) And FileAttribute.txt‬‬ ‫‪Catch exc As Exception‬‬ ‫‪End Try‬‬ ‫در اﻳﻦ ﻣﺜﺎل ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﻌﺮﻳﻒ ﺳـﺎﺧﺘﺎر ‪ Error‬در ﺑﺮﻧﺎﻣـﻪ ﺑـﻪ وﺳـﻴﻠﻪ ‪ ،Try-Catch‬از رخ دادن‬ ‫ﺧﻄﺎي زﻣﺎن اﺟﺮا آﻪ ﻣﻤﻜﻦ اﺳﺖ ﺑﻪ دﻟﻴـﻞ وﺟـﻮد ﻧﺪاﺷـﺘﻦ ﻓﺎﻳـﻞ ‪ Log.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫‪SetAttr "C:\Windows\MyFile.‬‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﻓﺎﻳﻞ هﺎي ﭘﺎك ﺷﺪﻩ ﺑﻪ ﺳﻄﻞ زﺑﺎﻟـﻪ وﻳﻨـﺪوز ﻣﻨﺘﻘـﻞ ﻧﻤـﻲ ﺷـﻮﻧﺪ و ﺑـﺮاي‬ ‫هﻤﻴﺸﻪ ﭘﺎك ﺧﻮاهﻨﺪ ﺷﺪ‪..ReadOnly Then‬‬ ‫_ ‪reply=MsgBox(“This is a read-only file.‬‬ ‫در اﻳﻦ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮان ﻳﻚ ﻳﺎ ﭼﻨﺪ ﺻﻔﺖ را هﻤﺰﻣﺎن اﻳﺠﺎد ﻳﺎ ﺣﺬف آﺮد‪.ReadOnly‬‬ ‫)‪Kill(file_name‬‬ ‫‪End If‬‬ ‫‪Else‬‬ ‫)‪Kill(file_name‬‬ ‫‪End If‬‬ ‫در اﻳﻦ ﻣﺜﺎل‪ ،‬ﻓﺎﻳﻞ در ﻣﻮرد داﺷﺘﻦ ﺻﻔﺖ ﻓﻘﻂ ﺧﻮاﻧﺪﻧﻲ ﭼﻚ ﻣﻲ ﺷﻮد و در ﺻـﻮرت داﺷـﺘﻦ ﺁن ﺑـﺎ‬ ‫ﭘﺮﺳﺸﻲ از آﺎرﺑﺮ در ﻣﻮرد ﺣﺬف ﺁن ﺗﺎﻳﻴﺪ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد‪.Yes Then‬‬ ‫)‪SetAttr(file_name.‬‬ ‫ﺑﻪ ﻣﺜﺎل زﻳﺮ دﻗﺖ آﻨﻴﺪ‪:‬‬ ‫‪If GetAttr(file_name) And FileAttribute.‬‬ ‫)‪Kill(pathname‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻓﺎﻳﻞ ﻳﺎ ﻓﺎﻳﻞ هﺎﻳﻲ را آﻪ ﻣﺴﻴﺮ و ﻧﺎم ﺁﻧﻬﺎ در ﺁرﮔﻮﻣﺎن ‪ pathname‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد ﭘﺎك‬ ‫ﻣﻲ آﻨﺪ‪.YesNo‬‬ ‫‪If reply=MsgBoxResult.Delete it anyway?”.FileAttribute.‬ﻣﻌﺮف هﻤﻪ( و‬ ‫)؟ ﻣﻌﺮف ﻳﻚ آﺎراآﺘﺮ(‬ ‫اﮔﺮ ﻓﺎﻳﻠﻲ آﻪ ﻧﺎم ﺁن در ﺁرﮔﻮﻣﺎن ‪ pathname‬ذآﺮ ﻣـﻲ ﺷـﻮد وﺟـﻮد ﻧﺪاﺷـﺘﻪ ﺑﺎﺷـﺪ‪ ،‬ﻳـﻚ ﺧﻄـﺎي‬ ‫‪) RunTime‬زﻣﺎن اﺟﺮا ( اﺗﻔﺎق ﻣﻲ اﻓﺘﺪ‪.Hidden Then‬‬ ‫)‪SetAttr(file_name.‬‬ ‫)‪MsgBoxStyle.txt‬در ﻣـﺴﻴﺮ ذآـﺮ ﺷـﺪﻩ‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.txt".NET‬‬ ‫‪١١‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .

txt”) & “bytes‬‬ ‫ﻣﻴﺰان ﺣﺠﻢ ﻓﺎﻳﻞ ﺗﻌﻴﻴﻦ ﺷﺪﻩ در آﺎدر ﻣﺤﺎورﻩ ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ‪.‬ﺑﻪ ﻋﺒﺎرت دﻳﮕﺮ ﺷﻤﺎ ﻧﻤﻲ ﺗﻮاﻧﻴﺪ ﭼﻨﺪﻳﻦ ﭘﻮﺷﻪ را ﺑـﺎ ﻳـﻚ ﺑـﺎر ﻓﺮاﺧـﻮاﻧﻲ اﻳـﻦ ﺗـﺎﺑﻊ ﺣـﺬف‬ ‫آﻨﻴﺪ‪.txt‬‬ ‫ﺗﺎرﻳﺦ و زﻣﺎن ﺑﺮﮔﺸﺘﻲ ﻓﺮﺿﺎ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺧﻮاهﺪ ﺑﻮد‪:‬‬ ‫”‪“21/11/01 14:13:02 PM‬‬ ‫)‪FileLen(pathname‬‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻋﺪدي از ﻧـﻮع ‪ Long Integer‬ﺧﻮاهـﺪ ﺑـﻮد آـﻪ ﻣﻴـﺰان ﺣﺠـﻢ ﻓـﺎﻳﻠﻲ را‬ ‫ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ ﻧﺎم ﺁن در ﺁرﮔﻮﻣﺎن ‪ pathname‬ﺁﻣﺪﻩ اﺳﺖ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،path‬ﻧﺎم ﭘﻮﺷﻪ و ﻣﺴﻴﺮي اﺳﺖ آﻪ ﻗﺼﺪ اﻳﺠﺎد ﺁن را دارﻳﻢ‪.‬اﻟﺒﺘـﻪ اﮔـﺮ‬ ‫ﭘﻮﺷﻪ ‪ Users‬وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﺪ‪(.‬‬ ‫)‪MkDir(path‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﭘﻮﺷﻪ )داﻳﺮآﺘﻮري( ﺟﺪﻳﺪ را اﻳﺠﺎد ﻣﻲ آﻨﺪ‪.‬ﺟﻬــﺖ اﻃﻼﻋــﺎت ﺑﻴــﺸﺘﺮ‪ ،‬ﺗﻮﺿــﻴﺤﺎت ﺗــﺎﺑﻊ )(‪ LOF‬را آــﻪ در ﮔــﺮوﻩ ﺗﻮاﺑــﻊ‬ ‫ورودي‪/‬ﺧﺮوﺟﻲ ﻓﺎﻳﻞ هﺎ )‪ (File I/O‬دﺳﺘﻪ ﺑﻨﺪي ﺷﺪﻩ اﺳﺖ ﺑﺒﻴﻨﻴﺪ‪.‬‬ ‫ﺑﻪ ﻣﺜﺎل زﻳﺮ ﺗﻮﺟﻪ آﻨﻴﺪ‪:‬‬ ‫)”‪MkDir(“C:\Users \New User‬‬ ‫اﻳﻦ دﺳﺘﻮر‪ ،‬ﭘﻮﺷﻪ اي ﺟﺪﻳﺪ ﺑﻪ ﻧـﺎم ‪ New Users‬در ﭘﻮﺷـﻪ ‪ Users‬اﻳﺠـﺎد ﻣـﻲ آﻨـﺪ‪) .WriteLine(FileDateTime(“myDocument.‬اﻟﺒﺘﻪ اﮔﺮ ﭘﻮﺷﻪ وﺟﻮد داﺷﺖ‪ ،‬ﻣﻲ ﺗﻮاﻧﻴﺪ ﺁن را ﺣﺬف و اﻗﺪام ﺑﻪ اﻳﺠﺎد ﭘﻮﺷﻪ ي ﺟﺪﻳﺪ آﻨﻴﺪ(‬ ‫)‪RmDir(path‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺑﺮاي ﺣﺬف ﭘﻮﺷﻪ ﻳﺎ داﻳﺮآﺘﻮري آﻪ ﻣﺴﻴﺮ و ﻧﺎم ﺁن در ﺁرﮔﻮﻣﺎن ‪ Path‬ﺁﻣـﺪﻩ اﺳـﺖ ﺑـﻪ آـﺎر‬ ‫ﻣﻲ رود‪.NET‬‬ ‫‪١٢‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ‪ :‬ﺗﺎﺑﻊ )(‪ FileLen‬ﺑـﺎ ﺗـﺎﺑﻊ )(‪) LOF‬آـﻪ ﺣﺠـﻢ ﻓـﺎﻳﻠﻲ را آـﻪ هـﻢ اآﻨـﻮن ﺑـﺎز اﺳـﺖ ﺑﺮﻣـﻲ‬ ‫ﮔﺮداﻧــﺪ( ﺗﻔــﺎوت دارد‪ .‬‬ ‫)‪FileDateTime(pathname‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﺎرﻳﺦ و زﻣﺎن اﻳﺠﺎد ﻳﻚ ﻓﺎﻳـﻞ ﻳـﺎ ﺗـﺎرﻳﺦ و زﻣـﺎن ﺁﺧـﺮﻳﻦ زﻣـﺎﻧﻲ آـﻪ ﻓﺎﻳـﻞ ﺗﻐﻴـﺮ ﭘﻴـﺪا آـﺮدﻩ و‬ ‫وﻳﺮاﻳﺶ ﺷﺪﻩ اﺳﺖ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‫اﻳﺠﺎد ﺷﻮد ﻳﺎ هﺮ دﻟﻴﻞ دﻳﮕﺮي آﻪ ﻣﻤﻜﻦ اﺳﺖ از ﺣﺬف ﻓﺎﻳﻞ ﺟﻠﻮﮔﻴﺮي آﻨﺪ‪ ،‬ﺟﻠـﻮﮔﻴﺮي ﺷـﺪﻩ و در‬ ‫ﺻﻮرت رخ دادن ﺧﻄﺎ‪ ،‬آﻨﺘﺮل ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺧﻂ ﺑﻌﺪ ﻣﻨﺘﻘﻞ ﻣﻲ ﺷﻮد‪.‬‬ ‫ﻧﻜﺎت ﻣﻬﻢ در اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ‪ :‬ﺁرﮔﻮﻣﺎن ‪ Path‬ﻧﻤﻲ ﺗﻮاﻧـﺪ داراي آﺎراآﺘﺮهـﺎي ﺟﺎﻧـﺸﻴﻨﻲ )* و‬ ‫؟( ﺑﺎﺷﺪ‪ .‬‬ ‫هﻤﭽﻨﻴﻦ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﻪ ﻳﻚ ﻣﺴﻴﺮ ﻳﺎ ﭘﻮﺷﻪ دﻟﺨﻮاﻩ ﺳﻮﻳﭻ آﺮدﻩ و ﭘﻮﺷﻪ هﺎي ﺧﻮد را در ﺁﻧﺠـﺎ‬ ‫اﻳﺠﺎد آﻨﻴﺪ‪.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫))”‪Console.\docs \myDocument.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫)”‪MsgBox(“The file contains” & FileLen(“.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫)”\‪ChDrive(“C:‬‬ ‫)”\‪ChDir(“C:‬‬ ‫)”‪MkDir(“Users‬‬ ‫)”‪ChDir(“Users‬‬ ‫)”‪MkDir(“New User‬‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ‪ :‬ﺣﺘﻤﺎ از ﺳﺎﺧﺘﺎر ‪ Try-Catch‬در ﺳﺎﺧﺖ ﭘﻮﺷﻪ هﺎ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ ﭼﻮن در ﺻـﻮرﺗﻲ آـﻪ‬ ‫ﭘﻮﺷﻪ اي آﻪ ﻗﺼﺪ اﻳﺠﺎد ﺁن را دارﻳﺪ در ﻣﺴﻴﺮ ذآﺮ ﺷﺪﻩ وﺟﻮد داﺷﺘﻪ ﺑﺎﺷـﺪ‪ ،‬ﺧﻄـﺎﻳﻲ رخ ﺧﻮاهـﺪ‬ ‫داد‪) .

‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔﺮ دراﻳﻮ ﺟﺎري )‪ (C:‬ﺑﺎﺷﺪ‪ ،‬دﺳﺘﻮر زﻳﺮ ﭘﻮﺷﻪ ﺟﺎري را ﺑـﻪ ﭘﻮﺷـﻪ دﻳﮕـﺮي در دراﻳـﻮ‬ ‫)‪ (D:‬ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ اﻣﺎ دراﻳﻮ )‪ (C:‬ﺑﻪ ﻋﻨﻮان دراﻳﻮ ﺟﺎري ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ‪:‬‬ ‫”‪ChDir “D:\TMP‬‬ ‫ﺑﺮاي ﺗﻐﻴﻴﺮ دراﻳﻮ ﺟﺎري از ﺗـﺎﺑﻊ )(‪ ChDrive‬آـﻪ ﺑـﻪ ﻋﻨـﻮان ﺗـﺎﺑﻊ ﺑﻌـﺪي ﺗﻮﺿـﻴﺢ دادﻩ ﺷـﺪﻩ اﺳـﺖ‬ ‫اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.‬‬ ‫ﺷﻤﺎ هﻤﭽﻨﻴﻦ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻧﺎم هﺎي ﻧﺴﺒﻲ را ﺑﻪ ﻋﻨﻮان ﻧﺎم ﭘﻮﺷﻪ ﺑﻪ آﺎر ﺑﺒﺮﻳﺪ‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل دﺳﺘﻮر )”‪ ChDir(“.‬‬ ‫)‪ChDrive(drive‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ دراﻳﻮ ﺟﺎري را ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ‪ .‫ﺑﺮاي ﺣﺬف ﭘﻮﺷﻪ‪ ،‬ﺑﺎﻳﺪ دو ﺷﺮط زﻳﺮ ﺑﺮﻗﺮار ﺑﺎﺷﺪ‪:‬‬ ‫‪ (١‬ﭘﻮﺷﻪ ﺧﺎﻟﻲ ﺑﺎﺷﺪ‪ (٢ .‬‬ ‫ﭘﺲ ﻓﺮﻣﺎن ﻓﻮق را ﺑﻪ ﺻﻮرت زﻳﺮ اﺻﻼح ﻣﻲ آﻨﻴﻢ‪:‬‬ ‫)”‪RmDir(“C:\Users \New User‬‬ ‫)”‪RmDir(“C:\Users‬‬ ‫)‪ChDir(path‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﭘﻮﺷﻪ )داﻳﺮآﺘﻮري( ﺟﺎري را ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ‪.‬‬ ‫در ﺻﻮرت رﻋﺎﻳﺖ ﻧﻜﺮدن هﺮ ﻳﻚ از ﻣﻮارد ﻓﻮق‪ ،‬ﻳﻚ ﺧﻄﺎي زﻣﺎن اﺟﺮا اﺗﻔﺎق ﻣﻲ اﻓﺘﺪ‪.‬‬ ‫ﻧﻜﺎت ﻣﻬﻢ‪ :‬دراﻳﻮي آﻪ ﻧﺎم ﺁن در ﺁرﮔﻮﻣﺎن ‪ drive‬ذآﺮ ﻣﻲ ﺷﻮد ﺑﺎﻳﺪ وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬ ‫)] ‪CurDir([drive‬‬ ‫هﻨﮕﺎﻣﻲ آﻪ اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﺑﺪون ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ drive‬ﻓﺮاﺧﻮاﻧﻲ ﺷﻮد‪ ،‬ﻧﺎم ﭘﻮﺷﻪ ﺟﺎري را در دراﻳـﻮ‬ ‫ﺟﺎري ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬ﻋـﻼوﻩ ﺑـﺮ ﺁن اﮔـﺮ ﭘﻮﺷـﻪ ي ﺷـﻤﺎ داراي ﺗﻌـﺪادي‬ ‫زﻳﺮﭘﻮﺷﻪ ﻧﻴﺰ ﺑﺎﺷﺪ‪ ،‬ﺑﺎﻳﺪ ﺁﻧﻬﺎ را هﻢ ﻗﺒﻞ از ﺣﺬف ﭘﻮﺷﻪ ي اﺻﻠﻲ ﺣﺬف آﻨﻴﺪ‪..‬ﭘﻮﺷﻪ ﺟﺎري را ﻳﻚ ﻣﺮﺣﻠﻪ ﺑﻪ ﺑﺎﻻ در ﭘﻮﺷﻪ اﺻﻠﻲ اﻧﺘﻘﺎل ﻣﻲ‬ ‫دهــﺪ در ﺻــﻮرﺗﻲ آــﻪ دﺳــﺘﻮر )”‪ ،ChDir(“.‬‬ ‫ﺑﺮاي ﺣﺬف ﭘﻮﺷﻪ اي آﻪ داراي ﺗﻌﺪادي ﻓﺎﻳـﻞ اﺳـﺖ‪ ،‬اﺑﺘـﺪا ﺑـﺎ ﺗـﺎﺑﻊ )(‪ Kill‬ﻓﺎﻳـﻞ هـﺎي درون ﺁن را‬ ‫ﺣﺬف و ﺳﭙﺲ ﺗﺎﺑﻊ ‪ RmDir‬را ﻓﺮاﺧﻮاﻧﻲ آﻨﻴـﺪ‪ .‬‬ ‫ﻓﺮﻣﺎن زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫)”‪RmDir(“C:\Users‬‬ ‫در ﺻﻮرﺗﻲ آﻪ ﭘﻮﺷﻪ ي ‪ Users‬داراي زﻳﺮﭘﻮﺷـﻪ اي ﺑـﻪ ﻧـﺎم ‪ New User‬ﺑﺎﺷـﺪ‪ ،‬ﺧﻄـﺎﻳﻲ اﺗﻔـﺎق‬ ‫ﻣﻲ اﻓﺘﺪ‪.‬‬ ‫اﮔﺮ در ﺁرﮔﻮﻣﺎن ‪ drive‬ﻧﺎم ﭼﻨﺪﻳﻦ دراﻳﻮ ذآﺮ ﺷﻮد‪ ،‬ﻧﺎم اوﻟﻴﻦ دراﻳﻮ ﺟﻬﺖ ﺗﻐﻴﻴﺮ در ﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﻣـﻲ‬ ‫ﺷﻮد‪..‬‬ ‫ﺑﺮاي اﻳﻨﻜﻪ ﺑﻔﻬﻤﻴﺪ آﻪ آﺪام ﭘﻮﺷﻪ در دراﻳﻮ دﻳﮕﺮي ﭘﻮﺷﻪ ﺟـﺎري اﺳـﺖ‪ ،‬ﻧـﺎم دراﻳـﻮ را در ﺁرﮔﻮﻣـﺎن‬ ‫‪ drive‬ذآﺮ آﻨﻴﺪ‪.‬‬ ‫ﺗﻮﺟﻪ‪ :‬ﺗﺎﺑﻊ )(‪ ،ChDir‬ﭘﻮﺷﻪ ﺟﺎري را ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ ﻧﻪ دراﻳﻮ ﺟﺎري را‪.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬ﭘﻮﺷﻪ ﺟﺎري ﻧﺒﺎﺷﺪ‪.NET‬‬ ‫‪١٣‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﺗﻮﺟﻪ‪ :‬هﻢ ﭘﻮﺷﻪ ي ﺟﺎري و هﻢ ﭘﻮﺷﻪ ي ‪ ،MyFiles‬دو زﻳﺮﭘﻮﺷﻪ در ﻳﻚ ﭘﻮﺷﻪ اﺻﻠﻲ هﺴﺘﻨﺪ‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺑﺮاي ﺳﻮﻳﭻ ﺑﻪ ﭘﻮﺷﻪ ‪ C:\Windows‬ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ‪:‬‬ ‫)”‪ChDir(“C:\Windows‬‬ ‫ﻧﻜﺎت ﻣﻬﻢ‪ :‬اﮔﺮ در ﺁرﮔﻮﻣﺎن ‪ path‬اﻳﻦ ﺗـﺎﺑﻊ از ﺁوردن ﻧـﺎم دراﻳـﻮ ﺧـﻮدداري ﺷـﻮد‪ ،‬ﺗـﺎﺑﻊ )(‪ChDir‬‬ ‫ﺗﻼش ﻣﻲ آﻨﺪ ﺗﺎ در دراﻳﻮ ﺟﺎري ﺑﻪ ﭘﻮﺷﻪ اي آـﻪ ﻧـﺎم ﺁن در در ﺁرﮔﻮﻣـﺎن ‪ path‬ﻣـﺸﺨﺺ ﺷـﺪﻩ‬ ‫ﺳﻮﻳﭻ آﻨﺪ و اﮔﺮ ﭘﻮﺷﻪ وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ‪ ،‬ﻳﻚ ﺧﻄﺎ رخ ﻣﻲ دهﺪ و ﻣﺴﻴﺮ ﺟﺎري ﺗﻐﻴﻴﺮ ﭘﻴﺪا ﻧﻤﻲ‬ ‫آﻨﺪ‪.\MyFiles‬ﭘﻮﺷــﻪ ‪ MyFiles‬را در ﭘﻮﺷــﻪ اﺻــﻠﻲ ﺑــﻪ‬ ‫ﻋﻨﻮان ﭘﻮﺷﻪ ﺟﺎري در ﻧﻈﺮ ﻣﻲ ﮔﻴﺮد‪.‬هﻤﺎﻧﻨﺪ‪ChDrive(“D:”) :‬‬ ‫اﻳﻦ دﺳﺘﻮر‪ ،‬دراﻳﻮ ﺟﺎري را ﺑﻪ دراﻳﻮ ‪ D‬ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ‪.

NET‬‬ ‫‪١٤‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﻳﻜﻲ از آﺎرﺑﺮدهﺎي اﻳﻦ ﺗﺎﺑﻊ ﺑﺮاي ﺗﻌﻴﻴﻦ وﺟﻮد ﻳﻚ ﻓﺎﻳﻞ ﻳﺎ ﭘﻮﺷﻪ در ﻣﺴﻴﺮ ﻣﺸﺨﺺ ﺷﺪﻩ اﺳﺖ‪.FileAttribute.‬‬ ‫ﭘﺲ ﺗﺎﺑﻊ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻣﻲ ﺷﻮد‪:‬‬ ‫)‪DLLFile =Dir(“C:\WINNT \SYSTEM \*.‬اﻳﻦ آﺎر ﺑﺮاي ﺗﻤﺎﻣﻲ ﻓﺎﻳﻞ هﺎي ‪ DLL‬در ﻣﺴﻴﺮ ﻣـﺸﺨﺺ ﺷـﺪﻩ اداﻣـﻪ ﻣـﻲ ﻳﺎﺑـﺪ و در ﺁﺧـﺮ‪،‬‬ ‫ﻣﻘﺪار ﻣﺘﻐﻴﺮ ‪ ،DLLFiles‬ﺗﻌﺪاد ﻓﺎﻳﻞ هﺎي ﻣﺸﺨﺺ ﺷﺪﻩ در ﻣﺴﻴﺮ ﺗﻌﻴﻴﻦ ﺷﺪﻩ را دارا ﻣﻲ ﺑﺎﺷﺪ‪.Hidden‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬‬ ‫اﮔﺮ هﻴﭻ ﻓﺎﻳﻠﻲ ﺑﺎ ﺁرﮔﻮﻣﺎن هﺎي ذآﺮ ﺷﺪﻩ در ﺗﺎﺑﻊ )(‪ Dir‬ﺻﺪق ﻧﻜﻨﺪ‪ ،‬ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ‪ ،‬ﻳـﻚ ﻣﻘـﺪار‬ ‫ﺧﺎﻟﻲ ﺧﻮاهﺪ ﺑﻮد‪.WriteLn sFile‬‬ ‫)(‪sFile = Dir‬‬ ‫‪Loop‬‬ ‫در اﻳﻦ ﻣﺜﺎل‪ ،‬آﻠﻴﻪ ﻓﺎﻳﻞ هﺎﻳﻲ آﻪ در ﭘﻮﺷﻪ ‪ Windows‬وﺟﻮد دارﻧﺪ)در ﭘﻮﺷـﻪ اﺻـﻠﻲ ‪Windows‬‬ ‫ﻧﻪ در زﻳﺮ ﭘﻮﺷﻪ هﺎي ﺁن( ﭼﺎپ ﺧﻮاهﻨﺪ ﺷﺪ‪.‬‬ ‫هﺮ ﺑﺎر آﻪ ﺗﺎﺑﻊ‪ ،‬ﻧﺎم ﻳﻚ ﻓﺎﻳﻞ ‪ DLL‬را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ ﻳﻚ واﺣﺪ ﺑﻪ ﻣﺘﻐﻴﺮ ‪ DLLFiles‬اﺿـﺎﻓﻪ ﻣـﻲ‬ ‫ﺷﻮد‪ .‬‬ ‫در اﻳﻦ ﻣﺜﺎل ﻣﻲ ﺧﻮاهﻴﻢ ﺑﺪاﻧﻴﻢ آﻪ ﭼﻨﺪ ﻓﺎﻳﻞ ﺑﺎ ﭘﺴﻮﻧﺪ ‪ DLL‬در ﻣﺴﻴﺮي آﻪ ﻣﺸﺨﺺ ﻣﻲ آﻨـﻴﻢ‬ ‫وﺟﻮد دارد‪:‬‬ ‫‪Dim DLLFile As String‬‬ ‫‪Dim DLLFiles As Integer‬‬ ‫)”‪DLLFile =Dir(“C:\WINNT \SYSTEM \*.OCX‬‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ ﻓﺮﻣﺎن در ﺻﻮرت وﺟﻮد ﻓﺎﻳﻞ ‪ MSCOMCTL.‬‬ ‫اﮔﺮ ﻳﻚ ﻓﺎﻳﻞ ‪ DLL‬در ﻣﺴﻴﺮ ﻣﺸﺨﺺ ﺷﺪﻩ وﺟﻮد داﺷﺖ‪ ،‬ﻧﺎم ﺁن ﺑﺮﮔـﺸﺖ دادﻩ ﻣـﻲ ﺷـﻮد و ﺗـﺎﺑﻊ‬ ‫ﻣﺠﺪدا ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ ﺷﻮد اﻣﺎ اﻳﻦ ﺑﺎر ﺑﺪون ﺁرﮔﻮﻣﺎن‪.‬و ؟(‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫‪Dim sFile As String‬‬ ‫)"\‪sFile = Dir("C:\Windows‬‬ ‫‪Do Until sFile = vbNullString‬‬ ‫‪Console.‬‬ ‫ﺑﺮاي اﻳﻨﻜﻪ ﺑﻔﻬﻤﻴﻢ آﻪ ﭘﻮﺷﻪ ﺟﺎري در ﻳﻚ دراﻳﻮ دﻳﮕﺮ ﻣـﺜﻼ )‪ (D:‬ﭼﻴـﺴﺖ‪ ،‬ﺗـﺎﺑﻊ )(‪ CurDir‬را ﺑـﻪ‬ ‫ﺻﻮرت زﻳﺮ ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ آﻨﻴﻢ‪:‬‬ ‫)”‪DDir =CurDir(“D‬‬ ‫)]] ‪Dir([pathname [.‬‬ ‫ﺧﻮب ﻣﻲ ﺧﻮاهﻴﻢ ﺗﺎﺑﻊ را ﮔﺴﺘﺮش دهﻴﻢ و ﻓﻘﻂ ﻓﺎﻳﻞ هﺎي ‪ DLL‬اي را ﺟـﺴﺘﺠﻮ آﻨـﻴﻢ آـﻪ داراي‬ ‫ﺻﻔﺖ ‪) Hidden‬ﻣﺨﻔﻲ( هﺴﺘﻨﺪ‪.‬‬ ‫ﺑﻪ ﻓﺮﻣﺎن زﻳﺮ ﺗﻮﺟﻪ آﻨﻴﺪ‪:‬‬ ‫)”‪OCXFile =Dir(“C:\WINDOWS \SYSTEM \MSCOMCTL.‬‬ ‫دوﻣﻴﻦ ﺁرﮔﻮﻣﺎن‪ ،‬ﻳﻚ ﻣﻘﺪار ﻋﺪدي ﻳﺎ ﺛﺎﺑﺖ اﺳـﺖ آـﻪ در ﺗﻮﺿـﻴﺤﺎت ﺗـﺎﺑﻊ )(‪ SetAttr‬ﺁﻣﺪﻧـﺪ و ﻣـﻲ‬ ‫ﺗﻮاﻧﺪ ﻳﻚ ﻣﻘﺪار ﻳﺎ ﺑﻴﺸﺘﺮ ﺑﺎﺷﺪ‪.‬‬ ‫ﻧﻜﺎت ﻣﻬﻢ در اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ‪:‬‬ ‫در اﻳﻦ ﺗﺎﺑﻊ ﻣﺠﺎز ﺑﻪ اﺳﺘﻔﺎدﻩ از ﻋﻼﻣﺖ هﺎي ﺟﺎﻳﮕﺰﻳﻦ هﺴﺘﻴﺪ‪ *).DLL‬‬ ‫‪If DLLFile <>“” Then DLLFiles =DLLFiles +1‬‬ ‫”“>< ‪While DLLFile‬‬ ‫)(‪DLLFile =Dir‬‬ ‫‪DLLFiles =DLLFiles +1‬‬ ‫‪End While‬‬ ‫)‪MsgBox(DLLFiles‬‬ ‫در اﻳﻦ دﺳﺘﻮرات‪ ،‬ﺗﺎﺑﻊ )(‪ Dir‬اﺑﺘﺪا ﺑﺎ ﻳﻜﻲ از ﺁرﮔﻮﻣﺎن هﺎﻳﺶ ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ ﺷﻮد‪.‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔﺮ ﺷﻤﺎ در ﻳـﻚ ﭘﻮﺷـﻪ در دراﻳـﻮ )‪ (C:‬ﺑﺎﺷـﻴﺪ‪ ،‬دﺳـﺘﻮر )(‪ CDir =CurDir‬ﻣـﺴﻴﺮ‬ ‫ﭘﻮﺷﻪ ﺟﺎري را در دراﻳﻮ ﺟﺎري ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬‬ ‫در ﺻﻮرﺗﻲ آﻪ از ذآﺮ اﻳﻦ ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ﺧﻮدداري ﺷﻮد‪ ،‬ﺗﻨﻬﺎ ﻓﺎﻳﻞ هﺎي ‪) Normal‬ﻓﺎﻳـﻞ هـﺎي‬ ‫ﺑﺪون ﺻﻔﺖ( ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﻨﺪ ﺷﺪ‪.DLL”.attributes‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬دو ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري را درﻳﺎﻓـﺖ آـﺮدﻩ و ﻳـﻚ ﻣﻘـﺪار از ﻧـﻮع رﺷـﺘﻪ اي را آـﻪ ﻧـﺎم ﻓﺎﻳـﻞ ﻳـﺎ‬ ‫ﭘﻮﺷﻪ اي اﺳﺖ آﻪ ﺑﺎ ﺁرﮔﻮﻣﺎن ‪) pathname‬ﻣـﺴﻴﺮ ﻓﺎﻳـﻞ ﻳـﺎ ﭘﻮﺷـﻪ( ﻳـﺎ ‪) attributes‬ﺻـﻔﺖ ﻳـﺎ‬ ‫ﺻﻔﺎت ﻓﺎﻳﻞ( ﻣﻄﺎﺑﻘﺖ دارد‪ ،‬ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.OCX‬در ﻣﺴﻴﺮ ذآﺮ ﺷﺪﻩ‪ ،‬هﻤﺎن‬ ‫ﻧﺎم ﻓﺎﻳﻞ اﺳﺖ در ﻏﻴﺮ اﻳﻨﺼﻮرت ﻳﻚ ﻣﻘﺪار ﺗﻬﻲ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد‪.

‬‬ ‫ﺑــــﺮاي ﺗﻌﻴــــﻴﻦ ﻧــــﺎم زﻳﺮﭘﻮﺷــــﻪ هــــﺎﻳﻲ آــــﻪ در ﻳــــﻚ ﭘﻮﺷــــﻪ ﻗــــﺮار دارﻧــــﺪ ﺑﺎﻳــــﺪ از ﺻــــﻔﺖ‬ ‫‪ FileAttribute.txt‬ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ dest_file‬ﻧﺎم ﻓﺎﻳﻞ و ﻣﺴﻴﺮي اﺳﺖ آﻪ ﻓﺎﻳﻞ ﻗﺮار اﺳﺖ ﺑﻪ ﺁﻧﺠﺎ آﭙﻲ ﺷﻮد‪.FName As String‬‬ ‫‪Dim totFolders As Integer‬‬ ‫”\‪path =“C:\Windows\System‬‬ ‫)‪FName =Dir(path.‬ﻣـﺜﻼ ﻓﺎﻳـﻞ هـﺎي ‪ DLL‬اي آـﻪ داراي‬ ‫ﺻﻔﺎت ﻣﺨﻔﻲ و ﻓﻘﻂ ﺧﻮاﻧﺪﻧﻲ و ﺳﻴﺴﺘﻤﻲ هﺴﺘﻨﺪ‪.txt‬را ﺑـﻪ ﻣﻜـﺎن ﺟﺪﻳـﺪي آﭙـﻲ آـﺮدﻩ و ﻧـﺎم ﻓﺎﻳـﻞ آﭙـﻲ ﺷـﺪﻩ را ﺑـﻪ‬ ‫‪ NewName.‬در ‪ VB.WriteLine(“Found“ & totFolders & “folders‬‬ ‫)‪FileCopy(source_file.‬‬ ‫)‪Rename(oldpath.“C:\All Users‬‬ ‫اﻳﻦ دﺳﺘﻮر‪ ،‬ﭘﻮﺷﻪ ‪ Users‬را در دراﻳﻮ ‪ C‬ﺑﻪ ‪ All Users‬ﺗﻐﻴﻴﺮ ﻧﺎم ﻣﻲ دهﺪ‪.FileAttribute.‬‬ ‫ﺳﻪ ﻧﻜﺘﻪ ﻣﻬﻢ در راﺑﻄﻪ ﺑﺎ اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ‪:‬‬ ‫‪ (١‬ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺮاي ﻓﺎﻳﻠﻲ آﻪ ﻗﺮار اﺳﺖ ﺑﻪ ﻣﻜﺎن دﻳﮕﺮي آﭙﻲ ﺷﻮد ﻧﺎم ﺟﺪﻳﺪي در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪.txt‬‬ ‫”‪destination =“D:\MasteringVB\NewName.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،source_file‬ﻧﺎم ﻓﺎﻳﻠﻲ اﺳﺖ آﻪ ﻗﺮار اﺳﺖ آﭙﻲ ﺷﻮد‪.Directory Then‬‬ ‫)‪Console.‬‬ ‫‪ (٢‬در ﺻﻮرﺗﻲ آﻪ در ﻣﻮﻗﻊ آﭙﻲ ﻓﺎﻳﻞ‪ ،‬ﺑﺮﻧﺎﻣﻪ ي دﻳﮕﺮي در ﺣـﺎل اﺳـﺘﻔﺎدﻩ از ﻓﺎﻳـﻞ ﺑﺎﺷـﺪ‪ ،‬ﻓﺎﻳـﻞ‬ ‫آﭙﻲ ﻧﺨﻮاهﺪ ﺷﺪ‪.‫ﺷﻤﺎ هﻤﭽﻨﻴﻦ ﻗﺎدر ﺑﻪ ﺗﺮآﻴﺐ ﭼﻨﺪﻳﻦ ﺻﻔﺖ ﺑﺎ هﻢ هـﺴﺘﻴﺪ‪ .‬و ؟( ﺑـﻪ ﻋﺒـﺎرت دﻳﮕـﺮ ﻧﻤـﻲ‬ ‫ﺗﻮاﻧﻴﺪ ﺗﻨﻬﺎ ﺑﺎ ﻳﻚ ﺑﺎر ﻓﺮاﺧﻮاﻧﻲ اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﭼﻨﺪﻳﻦ ﻓﺎﻳﻞ را هﻤﺰﻣﺎن آﭙﻲ آﻨﻴﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،oldpath‬ﻧﺎم و ﻣﺴﻴﺮ ﻓﺎﻳﻞ ﻳﺎ ﭘﻮﺷﻪ اي را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ ﻗﺮار اﺳﺖ ﺗﻐﻴﻴﺮ ﻧـﺎم ﭘﻴـﺪا‬ ‫آﻨﺪ و ﻧﺎم ﺟﺪﻳﺪ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺁرﮔﻮﻣﺎن ‪ newpath‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد‪.‬‬ ‫ﻣﺜﺎل زﻳﺮ ﺗﻌﺪاد زﻳﺮﭘﻮﺷﻪ هﺎي ﻣﻮﺟﻮد در ﭘﻮﺷﻪ ‪ System‬را ﺑﻪ دﺳﺖ ﻣﻲ ﺁورد‪:‬‬ ‫‪Dim path.6.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.0‬ﺑﺎ ﻧﺎم ‪ vbDirectory‬ﺷﻨﺎﺧﺘﻪ ﻣﻲ ﺷﻮد(‬ ‫ﺑﺮاي ﺗﻌﻴﻴﻦ اﻳﻨﻜﻪ ﻣﻘﺪار ورودي‪ ،‬ﻓﺎﻳﻞ اﺳﺖ ﻳﺎ ﭘﻮﺷﻪ ﺑﺎﻳـﺪ ﺧـﻮاص ﻣﻘـﺪار ورودي را ﺑـﺎ اﺳـﺘﻔﺎدﻩ از‬ ‫ﺗﺎﺑﻊ )(‪ GetAttr‬ﺑﺮرﺳﻲ آﻨﻴﺪ‪.destination‬‬ ‫اﻳﻦ دﺳـﺘﻮرات‪ ،‬ﻓﺎﻳـﻞ ‪ Files.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫)”‪Rename(“C:\Users”.newpath‬‬ ‫ﺑﺎ آﻤﻚ اﻳﻦ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻧﺎم ﻳﻚ ﻓﺎﻳﻞ ﻳﺎ ﭘﻮﺷﻪ را ﺗﻐﻴﻴﺮ دهﻴﺪ‪.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫”‪source =“C:\VB\Examples\Files.dest_file‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻳﻚ ﻓﺎﻳﻞ را ﺑﻪ ﻳﻚ ﻣﻜﺎن ﺟﺪﻳﺪ ﺑﺮ روي هﺎرددﻳﺴﻚ آﭙﻲ ﻣﻲ آﻨﺪ‪.WriteLine(FName‬‬ ‫‪totFolders =totFolders + 1‬‬ ‫‪End If‬‬ ‫)(‪FName =Dir‬‬ ‫‪End While‬‬ ‫)”‪Console.‬‬ ‫اﮔﺮ ﻓﺎﻳﻞ در ﭘﻮﺷﻪ ﺟﺎري ﺑﺎﺷﺪ ﻓﻘﻂ ذآﺮ ﻧﺎم ﻓﺎﻳﻞ آﻔﺎﻳـﺖ ﻣـﻲ آﻨـﺪ در ﻏﻴـﺮ اﻳﻨـﺼﻮرت ﺑﺎﻳـﺪ ﻣـﺴﻴﺮ‬ ‫آﺎﻣﻞ ﻓﺎﻳﻞ را ذآﺮ آﻨﻴﺪ‪.txt‬‬ ‫)‪FileCopy(source.‬‬ ‫هﻤﭽﻨﻴﻦ ﻣﻲ ﺗﻮاﻧﻴﺪ هﻤﺎن ﻧﺎم ﻗﺒﻠﻲ ﻓﺎﻳﻞ را ﺑﻨﻮﻳﺴﻴﺪ‪.‬‬ ‫‪ (٣‬در اﻳﻦ ﺗﺎﺑﻊ ﻣﺠﺎز ﺑﻪ اﺳﺘﻔﺎدﻩ از آﺎراآﺘﺮهﺎي ﺟﺎﻳﮕﺰﻳﻦ ﻧﻴﺴﺘﻴﺪ‪ *).NET‬‬ ‫‪١٥‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .Directory‬‬ ‫”“>< ‪While FName‬‬ ‫_=)‪If (GetAttr(path &FName)And FileAttribute.Directory‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ آﻪ ﻧﺎم ﭘﻮﺷﻪ اﻳﻲ را ﺑﺮ ﮔﺸﺖ ﻣﻲ دهﺪ آﻪ ﻧﺮﻣـﺎل ﻳـﺎ‬ ‫اﺻﻄﻼﺣﺎ ﺑﺪون ﺻﻔﺖ ﺑﺎﺷﺪ‪) .Directory‬‬ ‫‪FileAttribute.

cps‬ﺑﻪ ﻣﺴﻴﺮ ﻣﺸﺨﺺ ﺷﺪﻩ در دراﻳﻮ ‪ D‬ﻣﻨﺘﻘﻞ ﻣﻲ آﻨﺪ‪:‬‬ ‫)”‪Rename(“C:\AllUsers\User1\Profile1.cps”.NET‬‬ ‫‪١٦‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﺑﺮاي ﺗﻐﻴﻴﺮ ﻧﺎم دو ﻳﺎ ﭼﻨﺪ ﭘﻮﺷﻪ ي ﺗﻮ در ﺗﻮ ﺑﺎﻳﺪ ﺁﻧﻬﺎ را ﻳﻜﻲ ﻳﻜﻲ ﺗﻐﻴﻴﺮ ﻧﺎم دهﻴﺪ‪.‫ﻧﻜﺎت ﻣﻬﻢ در اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ‪:‬‬ ‫ﺗﻐﻴﻴﺮ ﻧﺎم ﭘﻮﺷﻪ‪ ،‬ﺗﺎﺛﻴﺮي در ﺷﺎﻣﻞ ﺑﻮدن زﻳﺮﭘﻮﺷﻪ هﺎ و ﻓﺎﻳﻞ هﺎ در ﺁن ﻧﺪارد‪.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic. “D:\New User\UserProfile.‬‬ ‫ﺑﻪ ﻋﻨﻮام ﻣﺜﺎل ﻓﺮﻣﺎن زﻳﺮ ﻓﺎﻳﻞ ‪ Profile1.‬‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ اﻳﻦ ﺗﺎﺑﻊ ﻗﺎدر ﺑﻪ اﻧﺘﻘﺎل ﭘﻮﺷﻪ هﺎ ﻧﻴﺴﺖ‪. “C:\All Users \User1‬‬ ‫ﺑﺎ اﺟﺮاي اﻳﻦ دﺳﺘﻮر‪ ،‬ﻳﻚ ﺧﻄﺎ اﺗﻔﺎق ﺧﻮاهﺪ اﻓﺘﺎد‪.‬‬ ‫اﮔﺮ ﺷﻤﺎ ﻗﺼﺪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ دو ﭘﻮﺷﻪ ﺗﻮ در ﺗﻮ را هﻤﺰﻣﺎن ﺗﻐﻴﻴﺮ ﻧﺎم دهﻴﺪ ﻳﻚ ﺧﻄـﺎ رخ ﺧﻮاهـﺪ‬ ‫داد‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪:‬‬ ‫)”‪Rename(“C:\Users \New User”.‬‬ ‫ﺗﺎﺑﻊ ‪ Reaname‬ﺑﺮ روي ﻓﺎﻳﻞ هﺎي ﺑﺎز ﻳﺎ ﻓﺎﻳﻞ هﺎﻳﻲ آـﻪ ﺗﻮﺳـﻂ ﺑﺮﻧﺎﻣـﻪ هـﺎي دﻳﮕـﺮ‪ ،‬هﻤﺰﻣـﺎن در‬ ‫ﺣﺎل اﺳﺘﻔﺎدﻩ هﺴﺘﻨﺪ آﺎرﺑﺮد ﻧﺪارد‪.cps‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻗﺎدر ﺑﻪ اﻳﺠﺎد ﻳﻚ ﭘﻮﺷﻪ ي ﺟﺪﻳﺪ ﻧﻴﺴﺖ‪.‬‬ ‫ﺗﺎﺑﻊ ‪ Rename‬هﻤﭽﻨﻴﻦ در ﺻﻮرت ﻧﻴﺎز‪ ،‬در هﻨﮕﺎم ﺗﻐﻴﻴﺮ ﻧﺎم ﻳﻚ ﻓﺎﻳﻞ ﻗﺎدر ﺑﻪ اﻧﺘﻘﺎل ﺁن )‪ (Cut‬ﺑﻪ‬ ‫ﻳﻚ ﻣﻜﺎن ﺟﺪﻳﺪ ﺑﺮ روي هﺎرددﻳﺴﻚ اﺳﺖ‪.cps‬را در ﻣﺴﻴﺮ ﻣﺸﺨﺺ ﺷﺪﻩ در دراﻳﻮ ‪ C‬هﻤﺮاﻩ ﺑﺎ‬ ‫ﺗﻐﻴﻴﺮ ﻧﺎم ﺁن ﺑﻪ ‪ UserProfile.‬‬ ‫در اﻳﻦ ﺗﺎﺑﻊ ﻣﺠﺎز ﺑﻪ اﺳﺘﻔﺎدﻩ از آﺎراآﺘﺮهﺎي ﺟﺎﻳﮕﺰﻳﻦ)* و ؟( ﻧﻴﺴﺘﻴﺪ‪.

‬‬ ‫)‪IsDate(expression‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ اﺳﺖ ﻳﺎ ﺧﻴﺮ‪ .‬‬ ‫‪ DBValue‬ﻣﻘﺪاري اﺳﺖ آﻪ وﺟﻮد ﻧﺪارد و ﺑﺎ ﻣﻘﺪار ‪ Nothing‬ﺗﻔﺎوت دارد‪.‬‬ ‫)‪IsNothing(expression‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ ﺁﻳﺎ ﻣﻘﺪاري )ﻣﺘﻐﻴﺮي( آﻪ از ﻧﻮع ‪) Object‬ﺷـﻲ( ﺗﻌﺮﻳـﻒ ﺷـﺪﻩ داراي‬ ‫ﻣﻘﺪار اﺳﺖ ﻳﺎ ﺧﻴﺮ‪ .‬‬ ‫)‪IsArray(variable‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ ﻳﻚ ﻣﺘﻐﻴﺮ از ﻧﻮع ﺁراﻳﻪ اﺳﺖ ﻳﺎ ﺧﻴﺮ‪ .‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫‪Dim obj As Object‬‬ ‫ﺑﻌﺪ از اﻳﻦ ﺗﻌﺮﻳﻒ‪ ،‬ﺧﺮوﺟﻲ ﻋﺒﺎرت )‪ IsNothing(obj‬ﺑﺮاﺑﺮ ‪ True‬اﺳـﺖ ﭼـﻮن هﻨـﻮز ﻣﻘـﺪاري ﺑـﻪ‬ ‫ﻣﺘﻐﻴﺮ ﻣﺎ ﻧﺴﺒﺖ دادﻩ ﻧﺸﺪﻩ اﺳﺖ‪.‬‬ ‫در اﻳﻦ ﻣﺜﺎل ﻣﻲ ﺗﻮان ﺑﺎ ﻧﻮﺷﺘﻦ ﻓﺮﻣﺎن ‪ ،Set obj=Nothing‬ﻓﻀﺎي اﺷﻐﺎل ﺷـﺪﻩ ﺣﺎﻓﻈـﻪ را آـﻪ‬ ‫ﺑﺮاي اﻳﺠﺎد اﻳﻦ ﺷﻲ در اﺧﺘﻴﺎر ﺑﺮﻧﺎﻣﻪ ﻗﺮار ﮔﺮﻓﺘﻪ اﺳﺖ ﺑﻪ ﺣﺎﻓﻈﻪ اﺻﻠﻲ ﺑﺮﮔﺮداﻧﺪ‪.NET‬‬ ‫‪١٧‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﻣﺜﺎل هﺎي زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫)‪Dim names(100‬‬ ‫)‪IsArray(names‬‬ ‫ﺧﺮوﺟﻲ اﻳﻦ ﺗﺎﺑﻊ ‪ True‬اﺳﺖ ﭼﻮن آﻪ ‪ names‬ﺑﻪ ﻋﻨﻮان ﻳﻚ ﺁراﻳﻪ ‪ ١٠٠‬ﺗﺎﻳﻲ ﺗﻌﺮﻳﻒ ﺷﺪﻩ اﺳﺖ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ variable‬ﻧﺎم ﻣﺘﻐﻴﺮي اﺳﺖ آﻪ ﺑﺎﻳﺪ ﺑﺮرﺳﻲ ﺷﻮد‪.‬‬ ‫‪ DBValue‬ﻧﻤﺎﻳﺎﻧﮕﺮ ﺁن اﺳﺖ آﻪ از ذآﺮ ﻳﻚ ﻣﻘﺪار ﺧﻮدداري ﺷﺪﻩ و ﻳﺎ ﻧﻮع ﺁن ﺗﻌﺮﻳﻒ ﻧﺸﺪﻩ‪.‬اﮔـﺮ ﻣﻘـﺪاراي ﺑـﻪ ﺁن ﻧـﺴﺒﺖ دادﻩ ﺷـﺪﻩ ﺑﺎﺷـﺪ‪ ،‬ﺧﺮوﺟـﻲ ﺗـﺎﺑﻊ ‪ True‬و ﮔﺮﻧـﻪ‬ ‫‪ False‬اﺳﺖ‪.‬‬ ‫‪Dim A As Integer‬‬ ‫)‪IsArray(A‬‬ ‫ﺧﺮوﺟﻲ ﺗﺎﺑﻊ در اﻳﻦ ﺣﺎﻟﺖ‪ False ،‬اﺳﺖ زﻳﺮا ‪ A‬ﻣﺘﻐﻴﺮي از ﻧﻮع ﺻﺤﻴﺢ ﺗﻌﺮﻳﻒ ﺷﺪﻩ اﺳﺖ‪.100.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ expression‬ﻋﺒﺎرﺗﻲ اﺳﺖ آﻪ ﺑﺎﻳﺪ ﭼﻚ ﺷﻮد‪.‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺮاي ﺷﻨﺎﺳﺎﻳﻲ ﻧﻮع دادﻩ هﺎ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‬ ‫)‪:(Data Type Identification‬‬ ‫ﺗﻮاﺑﻊ ﻣﻮﺟﻮد در اﻳﻦ ﺑﺨﺶ‪ ،‬ﺗﻨﻬﺎ ﻧﻮع دادﻩ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﻨﺪ‪.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫)”‪BDate =InputBox(“Please enter your birth date‬‬ ‫‪If IsDate(BDate)Then‬‬ ‫”‪MsgBox “Date accepted‬‬ ‫‪End If‬‬ ‫)‪IsDBNull(expression‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ در ﺻﻮرﺗﻲ آﻪ ﻳﻚ ﻣﻘﺪار‪ DBNull ،‬ﺑﺎﺷﺪ‪ ،‬ﻣﻘﺪار ‪ True‬را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.12‬‬ ‫ﺑﻌﺪ از اﺟﺮاي اﻳﻦ دﺳﺘﻮر‪ ،‬ﻣﺘﻐﻴﺮ ﻣﺎ داراي ﻣﻘﺪار اﺳﺖ و ﺧﺮوﺟﻲ ﻋﺒـﺎرت )‪ IsNothing(obj‬ﺑﺮاﺑـﺮ‬ ‫‪ False‬ﻣﻲ ﺑﺎﺷﺪ‪.‬‬ ‫ﺣﺎﻻ ﻣﺎ ﻳﻚ ﻣﻘﺪار از ﻧﻮع ‪) Object‬ﺷﻲ( را ﺑﻪ اﻳﻦ ﻣﺘﻐﻴﺮ ﻧﺴﺒﺖ ﻣﻲ دهﻴﻢ‪:‬‬ ‫)‪obj =New Rectangle(10.12.‬ﭼﻨﺎﻧﭽﻪ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ ﺑﺎﺷﺪ‪،‬‬ ‫ﺗﺎﺑﻊ ‪ True‬و ﮔﺮﻧﻪ ‪ False‬را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ‪.‬ﭼﻨﺎﻧﭽـﻪ از ﻧـﻮع ﺁراﻳـﻪ ﺑﺎﺷـﺪ‪ ،‬ﺗـﺎﺑﻊ‬ ‫ﻣﻘﺪار ‪ True‬و ﮔﺮﻧﻪ ‪ False‬را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ‪.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.

‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ هﻤﺎﻧﻨﺪ ﺗﺎﺑﻊ )(‪ TypeName‬ﻋﻤﻞ ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻳـﻚ ﻣﻘـﺪار ﻋـﺪدي‬ ‫را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ وﻟﻲ ﺗﺎﺑﻊ ‪ TypeName‬ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي را ﺑﺮﮔﺸﺖ ﺧﻮاهﺪ داد‪.‬‬ ‫ﻣﻘﺎدﻳﺮي آﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ در زﻳﺮ ﻟﻴﺴﺖ ﺷﺪﻩ اﺳﺖ‪:‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،Variable‬ﻣﺘﻐﻴﺮي اﺳﺖ آﻪ ﻧﻮع ﺁن ﺑﺎﻳﺪ ﻣﺸﺨﺺ ﺷﻮد‪.‬‬ ‫ﻓﺮض ﻣﻲ آﻨﻴﻢ آﻪ ﻣﺘﻐﻴﺮهﺎي زﻳﺮ ﺗﻌﺮﻳﻒ ﺷﺪﻩ اﻧﺪ‪:‬‬ ‫‪Dim name As Integer‬‬ ‫‪Dim a‬‬ ‫دﺳﺘﻮرات زﻳﺮ ﻧﺘﺎﻳﺞ زﻳﺮ را ﺗﻮﻟﻴﺪ ﻣﻲ آﻨﻨﺪ‪:‬‬ ‫))‪Console.WriteLine(TypeName(name‬‬ ‫‪Integer‬‬ ‫))‪Console.NET‬‬ ‫‪١٨‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .this time with a valid number‬‬ ‫‪End If‬‬ ‫در اﻳﻦ ﻣﺜﺎل ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ ،InputBox‬ﺳﻦ آﺎرﺑﺮ درﺧﻮاﺳﺖ ﻣـﻲ ﺷـﻮد و ﺳـﭙﺲ ﻣﻘـﺪار‬ ‫ورودي آﺎرﺑﺮ ﺑﺎ ﺗﺎﺑﻊ )(‪ IsNumeric‬ﭼﻚ ﻣﻲ ﺷـﻮد‪ .‬‬ ‫)‪IsReference(expression‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آـﻪ ﻳـﻚ ﻣﺘﻐﻴـﺮ از ﻧـﻮع ‪ Object‬ﻳـﺎ ‪ Reference‬اﺿـﺎﻓﻪ ﺷـﺪﻩ ﺑـﻪ ﺑﺮﻧﺎﻣـﻪ‬ ‫اﺳﺖ ﻳﺎ ﺧﻴﺮ و ﺧﺮوﺟﻲ ﺁن ﻳﺎ ‪ True‬و ﻳﺎ ‪ False‬اﺳﺖ‪.‬‬ ‫)‪IsNumeric(expression‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ رﺷﺘﻪ را ﺗﺴﺖ ﻣﻲ آﻨﺪ و ﭼﻨﺎﻧﭽﻪ آﻠﻴﻪ آﺎراآﺘﺮهﺎي رﺷﺘﻪ‪ ،‬ارﻗﺎم ﺑﻴﻦ ‪ 0‬ﺗﺎ ‪ 9‬ﺑﺎﺷـﻨﺪ‪،‬‬ ‫ﻣﻘﺪار ‪ True‬و ﮔﺮﻧﻪ ﻣﻘﺪار ‪ False‬را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.WriteLine(TypeName(a‬‬ ‫‪Nothing‬‬ ‫”‪a =“I ’m a string‬‬ ‫))‪Console.‫ﺑﻪ دو ﺷﻜﻞ ﻣﻲ ﺗﻮان اﻳﻦ ﺗﺎﺑﻊ را ﺑﻪ آﺎر ﺑﺮد‪:‬‬ ‫‪If IsNothing(obj) Then (١‬‬ ‫‪If obj Is Nothing Then (٢‬‬ ‫در ﺷﻜﻞ دوم‪ ،‬از آﻠﻤﻪ ي آﻠﻴﺪي )‪ (Is‬اﺳﺘﻔﺎدﻩ ﺷﺪﻩ اﺳﺖ‪.‬ﭼﻨﺎﻧﭽـﻪ آـﺎرﺑﺮ آـﺎراآﺘﺮي ﻏﻴـﺮ ﻋـﺪدي را وارد‬ ‫آﺮدﻩ ﺑﻮد‪ ،‬ﺑﻪ او اﻃﻼع دادﻩ ﻣﻲ ﺷﻮد‪.‬‬ ‫ﻣﻤﻜﻦ اﺳﺖ ﻣﺘﻐﻴﺮي آﻪ ﺷﻤﺎ ﻣﻲ ﺧﻮاهﻴﺪ ﻧﻮع ﺁن را ﺑﺎ اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ دﺳﺖ ﺁورﻳﺪ‪ ،‬ﺗﻌﺮﻳـﻒ ﺷـﺪﻩ ﻳـﺎ‬ ‫ﻧﺸﺪﻩ ﺑﺎﺷﺪ‪.WriteLine(TypeName(a‬‬ ‫‪String‬‬ ‫)‪VarType(variable‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻧﻮع ﻳﻚ ﻣﺘﻐﻴﺮ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬‬ ‫)‪TypeName(variable_name‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻧﻮع ﻳﻚ ﻣﺘﻐﻴﺮ را ﺑﻪ ﺻﻮرت رﺷﺘﻪ اي ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫)”‪age =InputBox(“Please enter your age‬‬ ‫‪If Not IsNumeric(age)Then‬‬ ‫)”‪MsgBox(“Please try again.

NET ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ‬ .‫ ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﺪ ﺷﺪ‬VarType() ‫ﻣﻘﺪار ﺛﺎﺑﺖ ﻋﺪدي اﻳﻦ ﻣﻘﺎدﻳﺮ ﺗﻮﺳﻂ ﺗﺎﺑﻊ‬ ‫ ﺑﻬﺮوز راد‬:‫ﺑﻪ وﺳﻴﻠﻪ‬ ١٩ Visual Basic.‫ ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‬VarType() ‫ﻣﻘﺎدﻳﺮي آﻪ ﺗﺎﺑﻊ‬ ‫ﻣﻘﺪار‬ Array Boolean Byte Char Currency DataObject Date Decimal Double Empty Error Integer Long Null Object Short Single String UserDefinedType Variant .

Double‬‬ ‫اوﻟﻴﻦ دﺳﺘﻮر‪ ،‬ﻣﻘﺪار ‪ ١٠٠٠‬را آﻪ از ﻧﻮع ﻋﺪد ﺻﺤﻴﺢ )‪ (Integer‬اﺳﺖ و دﺳﺘﻮر دوم ﻣﻘﺪار ‪١٠٠٠‬‬ ‫را آﻪ از ﻧﻮع رﺷﺘﻪ اي )‪ (String‬اﺳﺖ ﺑﻪ ﻧﻮع ﻋﺪد اﻋﺸﺎري ﺑﺎ دﻗﺖ ﻣﻀﺎﻋﻒ )‪ (Double‬ﺗﺒـﺪﻳﻞ‬ ‫ﻣﻲ آﻨﺪ‪.Double‬‬ ‫)‪CType(“1000”.‬‬ ‫ﺗﻤﺎﻣﻲ ﺗﻮاﺑﻊ اﻳﻦ ﺑﺨﺶ ﺁرﮔﻮﻣﺎن هﺎي ﻋﺪدي ﻣﻲ ﭘﺬﻳﺮﻧﺪ و ﺁﻧﻬﺎ را ﺗﺒﺪﻳﻞ ﺑﻪ ﻧﻮع دﻳﮕﺮي از ﻣﺘﻐﻴﺮهـﺎ‬ ‫ﻣﻲ آﻨﻨﺪ‪.‫ﺗﻮاﺑﻊ ﺗﺒﺪﻳﻞ ﻧﻮع ﻣﺘﻐﻴﺮ‬ ‫)‪:(Variable Type Conversion‬‬ ‫ﻣﺘﻐﻴﺮهﺎ ﻗﺎﺑﻠﻴﺖ ﺗﺒﺪﻳﻞ ﺷﺪن ﺑﻪ ﻳﻜﺪﻳﮕﺮ را دارﻧﺪ‪. System.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬ ‫‪٢٠‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫اﻳﻦ ﺗﻮاﺑﻊ را در ﺟﺪول زﻳﺮ ﻣﺸﺎهﺪﻩ ﻣﻲ آﻨﻴﺪ‪:‬‬ ‫ﺗﻮاﺑﻊ ﺗﺒﺪﻳﻞ ﻧﻮع ﻣﺘﻐﻴﺮ‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Boolean‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Byte‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Char‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Date‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Decimal‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Double‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Integer‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Long‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Object‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Short‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Single‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪String‬‬ ‫ﻧﻮع ﺳﻔﺎرﺷﻲ‬ ‫ﻧﺎم ﺗﺎﺑﻊ‬ ‫) ‪CBool(expression‬‬ ‫) ‪CByte(expression‬‬ ‫) ‪CChar(expression‬‬ ‫) ‪CDate(expression‬‬ ‫) ‪CDec(expression‬‬ ‫) ‪CDbl(expression‬‬ ‫) ‪CInt(expression‬‬ ‫) ‪CLng(expression‬‬ ‫) ‪CObj(expression‬‬ ‫) ‪Cshort(expression‬‬ ‫) ‪CSng(expression‬‬ ‫) ‪CStr(expression‬‬ ‫) ‪CType(expression. System.typeName‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻳﻚ ﻣﻘﺪار ﻳﺎ ﻋﺒﺎرت را آﻪ ﻣﻘﺪار ﺁن در ﺁرﮔﻮﻣﺎن ‪ varName‬ﺗﻌﻴﻴﻦ ﺷﺪﻩ ﺑﻪ ﻧـﻮﻋﻲ آـﻪ در‬ ‫ﺁرﮔﻮﻣﺎن ‪ typeName‬ﻣﺸﺨﺺ ﺷﺪﻩ ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ‪.‬‬ ‫دﺳﺘﻮرات زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫)‪CType(1000.type‬‬ ‫)‪CType(varName.

‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ رﺷﺘﻪ هﺎ ﺳﺮ و آﺎر دارﻧﺪ‬ ‫)‪:(String Manipulation‬‬ ‫در ‪ VB. AscW(string‬‬ ‫ﺗﺎﺑﻊ )(‪ ،Asc‬آﺪ اﺳﻜﻲ ﻳﻚ آﺎراآﺘﺮ را آﻪ ﻧـﺎم در ﺁرﮔﻮﻣـﺎن ‪ character‬ذآـﺮ ﺷـﺪﻩ‪ ،‬ﺑﺮﮔـﺸﺖ ﻣـﻲ‬ ‫دهﺪ‪. ChrW(number‬‬ ‫اﻳﻦ دو ﺗﺎﺑﻊ دﻗﻴﻘﺎ ﻋﻜﺲ ﺗﻮاﺑﻊ )(‪ Asc‬و )(‪ AscW‬ﻋﻤﻞ ﻣﻲ آﻨﻨﺪ‪.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫”‪Title =“Visual Basic.‬‬ ‫ﺗﺎﺑﻊ )(‪ AscW‬ﻋﻤﻠﻜﺮدي ﺷﺒﻴﻪ ﺑﻪ ﺗﺎﺑﻊ )(‪ Asc‬دارد ﺑﺎ اﻳـﻦ ﺗﻔـﺎوت آـﻪ آـﺪ اﺳـﻜﻲ آـﺎراآﺘﺮ را ﺑـﻪ‬ ‫ﺻﻮرت ‪ Unicode‬ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ در ﺻـﻮرﺗﻲ آـﻪ ﺗـﺎﺑﻊ )(‪ Asc‬آـﺪ اﺳـﻜﻲ را ﺑـﻪ ﺻـﻮرت ﺑﺎﻳـﺖ‬ ‫ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.‬‬ ‫)‪Chr(number) .NET‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬‬ ‫ﺗﻤــــــﺎﻣﻲ ﺗﻮاﺑــــــﻊ رﺷــــــﺘﻪ اي ‪ VB. UCase(string‬‬ ‫ﺗﺎﺑﻊ )(‪ ،Lcase‬در ﻳﻚ رﺷﺘﻪ‪ ،‬ﺣﺮوف ﺑﺰرگ رﺷﺘﻪ را ﺑﻪ ﺣﺮوف آﻮﭼﻚ ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ‪.String‬هﻤﺎﻧﻨﺪ آﻼس ‪ StringBuilder‬هﺴﺘﻨﺪ‪.‬‬ ‫)‪LCase(string) .‬‬ ‫از اﻳﻦ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺟﻬﺖ ﭼﺎپ ﺣﺮوف ﻳـﺎ آﺎراآﺘﺮهـﺎﻳﻲ آـﻪ ﺑـﺮ روي ﺻـﻔﺤﻪ آﻠﻴـﺪ وﺟـﻮد ﻧﺪارﻧـﺪ‬ ‫هﻤﺎﻧﻨﺪ ﺷﻜﻠﻚ هﺎ ﻳﺎ ﺣﺮوﻓﻲ آﻪ آﺪ اﺳﻜﻲ ﺁﻧﻬﺎ از ‪ 127‬ﺑﻴﺸﺘﺮ اﺳﺖ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.‬‬ ‫اﮔﺮ در ﺁرﮔﻮﻣﺎن ‪ character‬ﺑﻪ ﺟﺎي آﺎراآﺘﺮ‪ ،‬ﻳﻚ آﻠﻤﻪ ﻳﺎ رﺷﺘﻪ ﺁوردﻩ ﺷﻮد‪ ،‬اوﻟﻴﻦ آـﺎراآﺘﺮ رﺷـﺘﻪ‬ ‫در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد‪.‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺑﺮ روي هﻤﻪ ﺳﻴﺴﺘﻢ هﺎ آﺎر ﻣﻲ آﻨـﺪ ﺣﺘـﻲ اﮔـﺮ ﺁن ﺳﻴـﺴﺘﻢ از ‪ Unicode‬ﭘـﺸﺘﻴﺒﺎﻧﻲ‬ ‫ﻧﻜﻨﺪ‪.‬‬ ‫ﺗﺎﺑﻊ )(‪ ،Ucase‬در ﻳﻚ رﺷﺘﻪ‪ ،‬ﺣﺮوف آﻮﭼﻚ رﺷﺘﻪ را ﺑﻪ ﺣﺮوف ﺑﺰرگ ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ‪.‬‬ ‫از اﻳﻦ ﺗﻮاﺑﻊ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺟﻬﺖ ﺗﺒﺪﻳﻞ آﺪ اﺳﻜﻲ آﻠﻴﺪ ﻓﺸﺮدﻩ ﺷﺪﻩ ﺗﻮﺳﻂ آﺎرﺑﺮ ﺑﻪ آـﺎراآﺘﺮ ﻣﻌـﺎدل‬ ‫ﺁن اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.‬‬ ‫ﺑـﻪ ﻋﻨــﻮان ﻣﺜــﺎل ﻧﺘﻴﺠـﻪ ﺧﺮوﺟــﻲ )”‪ ،ASC(“Ali‬ﻋــﺪد ‪ 65‬اﺳــﺖ و ﻧﺘﻴﺠــﻪ ﺧﺮوﺟــﻲ )”‪،ASC(“N‬‬ ‫ﻋﺪد ‪ 78‬اﺳﺖ‪.‬‬ ‫)‪Asc(character) .‬‬ ‫در اﻳﻦ ﺑﺨﺶ دو ﺗﺎﺑﻊ هﻤﻨﺎم ﺑﻪ ﻧﺎم هﺎي )(‪ Mid‬و ‪ Mid‬وﺟﻮد دارد آـﻪ ﻋﻤﻠﻜـﺮدي ﺷـﺒﻴﻪ ﺑـﻪ هـﻢ‬ ‫داﺷﺘﻪ و در ﺟﺎي ﺧﻮد ﺑﺤﺚ ﺧﻮاهﻨﺪ ﺷﺪ‪.NET‬‬ ‫‪٢١‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .NET‬ﺗﻮاﺑﻊ ﺑﺴﻴﺎر ﻣﻬﻢ‪ ،‬ﻣﻔﻴﺪ و آﺎرﺁﻣﺪي ﺟﻬﺖ آﺎر ﺑﺎ رﺷﺘﻪ هﺎ وﺟﻮد دارﻧﺪ‪.‬‬ ‫از اﻳﻦ ﺗﻮاﺑﻊ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺟﻬﺖ ﺗﺒﺪﻳﻞ آﺎراآﺘﺮ آﻠﻴﺪ ﻓﺸﺮدﻩ ﺷﺪﻩ ﺗﻮﺳﻂ آﺎرﺑﺮ ﺑﻪ آﺪ اﺳـﻜﻲ ﻣﻌـﺎدل‬ ‫ﺁن اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.net‬‬ ‫”‪Utitle=”VISUAL BASIC.‬‬ ‫ﺗﺎﺑﻊ )(‪ ChrW‬ﻧﻴﺰ ﻳﻚ آﺎراآﺘﺮ از ﻧﻮع ‪ Unicode‬ﻳﻚ ﻣﻘﺪار ﻋﺪدي را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.Net‬‬ ‫)‪LTitle =LCase(Title‬‬ ‫)‪UTitle =UCase(Title‬‬ ‫ﺑﻌﺪ از اﺟﺮاي اﻳﻦ دﺳﺘﻮرات ﻣﺘﻐﻴﺮهﺎي ‪ Ltitle‬و ‪ ،Utitle‬داراي ﻣﻘﺎدﻳﺮ زﻳﺮ ﺧﻮاهﻨﺪ ﺷﺪ‪.‬‬ ‫ﻣﻴﺎﻧﮕﻴﻨﻲ آﻪ در راﺑﻄﻪ ﺑﺎ ﻋﻤﻠﻜﺮد ﺑﺮﻧﺎﻣﻪ هﺎي آﺎرﺑﺮدي ﮔﺮﻓﺘـﻪ ﺷـﺪﻩ ﻧـﺸﺎن ﻣـﻲ دهـﺪ آـﻪ ﺗﻮاﺑـﻊ‬ ‫رﺷﺘﻪ اي ﺑﻴﺶ از ﺗﻮاﺑﻊ ﻋﺪدي آﺎرﺑﺮد دارﻧﺪ‪.‬‬ ‫"‪Ltitle=”visual basic.‬‬ ‫ﺗﺎﺑﻊ )(‪ ،Chr‬آﺎراآﺘﺮ ﻣﻌﺎدل آﺪ اﺳﻜﻲ ﻳﻚ ﻋﺪد از ﻧﻮع ﺑﺎﻳﺖ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.NET‬داراي ﻣﺘــــــﺪ و ﺧــــــﻮاص ﻣــــــﺸﺎﺑﻪ و ﺑﺮاﺑــــــﺮ ي در‬ ‫آﻼس ‪ System.

‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﺁرﮔﻮﻣﺎن ‪ string2‬را در ﺁرﮔﻮﻣﺎن ‪ string1‬ﺟﺴﺘﺠﻮ ﻣﻲ آﻨﺪ‪.Text‬‬ ‫ﭘــﺲ از اﺟــﺮاي اﻳــﻦ دﺳــﺘﻮرات ﻣﻘــﺪار ﻣﺘﻐﻴــﺮ ‪ 1 ،pos‬ﺧﻮاهــﺪ ﺷــﺪ‪ .Binary‬ﺗﻐﻴﻴﺮ دهﻴﻢ ﻣﻘﺪار ﻣﺘﻐﻴﺮ ‪ 33 ،pos‬ﺧﻮاهﺪ ﺷﺪ‪. CompareMethod.‬‬ ‫اﮔﺮ رﺷﺘﻪ اول ﺑﺰرﮔﺘﺮ از رﺷﺘﻪ دوم ﺑﺎﺷﺪ‪ ،‬ﺗﺎﺑﻊ ﻣﻘﺪار ‪ 1‬را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.] string1.Text‬ﺗﻐﻴﻴﺮ دهﻴﺪ‪.‬‬ ‫ﺑـــﺮاي اﻳﻨﻜـــﻪ ﺑـــﺰرگ ﻳـــﺎ آﻮﭼـــﻚ ﺑـــﻮدن ﺣـــﺮوف‪ ،‬در ﺟـــﺴﺘﺠﻮ ﻧﺎدﻳـــﺪﻩ ﮔﺮﻓﺘـــﻪ ﺷـــﻮد‪ ،‬ﻣﻘـــﺪار‬ ‫ﺁرﮔﻮﻣﺎن ‪ Compare‬را ﺑﻪ ‪ CompareMethod.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫”‪str1 =“The quick brown fox jumped over the lazy dog‬‬ ‫”‪str2 =“the‬‬ ‫)‪Pos =Instr(str1.compare‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬زﻳﺮرﺷﺘﻪ اي را در رﺷﺘﻪ دﻳﮕﺮ ﺟﺴﺘﺠﻮ آﺮدﻩ و ﻣﺤﻞ وﺟـﻮد زﻳﺮرﺷـﺘﻪ در رﺷـﺘﻪ را ﺑﺮﻣـﻲ‬ ‫ﮔﺮداﻧﺪ‪.‬‬ ‫اﮔﺮ رﺷﺘﻪ دوم ﺑﺰرﮔﺘﺮ از رﺷﺘﻪ اول ﺑﺎﺷﺪ‪ ،‬ﺗﺎﺑﻊ ﻣﻘﺪار ‪ –1‬را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.Binary‬را دارد ﻣﻲ ﺗﻮاﻧﺪ ﺗﻐﻴﻴﺮ آﻨﺪ‪.‬‬ ‫اوﻟﻴﻦ ﺁرﮔﻮﻣﺎن‪ ،‬اﺧﺘﻴﺎري اﺳﺖ و ﻣﻜﺎﻧﻲ از رﺷﺘﻪ اﺳﺖ آﻪ ﺟـﺴﺘﺠﻮ ﺑﺎﻳـﺪ از ﺁﻧﺠـﺎ ﺁﻏـﺎز ﺷـﻮد‪ .‬‬ ‫ﺑـــﺮاي اﻳﻨﻜـــﻪ ﺑـــﺰرگ ﻳـــﺎ آﻮﭼـــﻚ ﺑـــﻮدن ﺣـــﺮوف‪ ،‬در ﻣﻘﺎﻳـــﺴﻪ ﻧﺎدﻳـــﺪﻩ ﮔﺮﻓﺘـــﻪ ﺷـــﻮد‪ ،‬ﻣﻘـــﺪار‬ ‫ﺁرﮔﻮﻣﺎن ‪ Compare‬را ﺑﻪ ‪ CompareMethod. str1.‬‬ ‫و اﻳﻦ ﺗﻨﻈﻴﻢ ﺑﻪ وﺳﻴﻠﻪ ﺗﻐﻴﻴﺮ ﺁﺧـﺮﻳﻦ ﺁرﮔﻮﻣـﺎن ﻳﻌﻨـﻲ ‪ compare‬آـﻪ ﺑـﻪ ﻃـﻮر ﭘـﻴﺶ ﻓـﺮض ﻣﻘـﺪار‬ ‫‪ CompareMethod.string2 [.compare‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ هﻤﺎﻧﻨـﺪ ﺗـﺎﺑﻊ )(‪ InStr‬ﻋﻤـﻞ ﻣـﻲ آﻨـﺪ ﺑـﺎ اﻳـﻦ ﺗﻔـﺎوت آـﻪ در ﺗـﺎﺑﻊ )(‪ InStr‬ﺟـﺴﺘﺠﻮ از‬ ‫اﺑﺘﺪاي رﺷﺘﻪ )ﭼﭗ ﺑﻪ راﺳـﺖ( وﻟـﻲ در ﺗـﺎﺑﻊ ‪ InStrRev‬ﺟـﺴﺘﺠﻮ از اﻧﺘﻬـﺎي رﺷـﺘﻪ )راﺳـﺖ ﺑـﻪ‬ ‫ﭼﭗ( اﻧﺠﺎم ﻣﻲ ﺷﻮد‪.‫)] ‪InStr([startPos.‬‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﺟﺎي ﺁرﮔﻮﻣﺎن ‪ start‬در اﻳﻦ ﺗﺎﺑﻊ ﻋﻮض ﺷﺪﻩ‪.start ][.‬‬ ‫ﻧﻜﺎت ﻣﻬﻢ‪:‬‬ ‫‪ (١‬اﮔﺮ رﺷﺘﻪ اي آﻪ ﺟﺴﺘﺠﻮ ﺑﺮاي ﺁن ﺁﻏﺎز ﻣﻲ ﺷﻮد ﺑﻴﺶ از ﻳـﻚ ﺑـﺎر در رﺷـﺘﻪ ﺟـﺴﺘﺠﻮ ﺷـﻮﻧﺪﻩ‬ ‫ﺗﻜﺮار ﺷﺪﻩ ﺑﺎﺷﺪ و آﻠﻤﻪ ﺑﺎﺷﺪ‪ ،‬ﻣﺤﻞ ﺁﺧﺮﻳﻦ وﺟﻮد ﺁن ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد هﻤﺎن ﻃﻮر آﻪ در‬ ‫اﻳﻦ ﻣﺜﺎل آﻠﻤﻪ ‪ ،the‬دوﺑﺎر ﺗﻜﺮار ﺷﺪﻩ اﺳﺖ اﻣﺎ اﮔﺮ ﻗـﺴﻤﺘﻲ از ﻳـﻚ آﻠﻤـﻪ ﺑﺎﺷـﺪ‪ ،‬ﺣﺘـﻲ اﮔـﺮ‬ ‫ﭼﻨﺪﻳﻦ ﺑﺎر هﻢ ﺗﻜﺮار ﺷﺪﻩ ﺑﺎﺷﺪ‪ ،‬ﻣﺤﻞ اوﻟﻴﻦ وﻗﻮع ﺁن ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﺪ ﺷﺪ‪.string2 [. str2. str2‬‬ ‫ﺑﻌﺪ از اﺟﺮاي دﺳﺘﻮرات ﻓﻮق‪ ،‬ﻣﺘﻐﻴﺮ ‪ Pos‬داراي ﻣﻘﺪار ‪ 33‬ﺧﻮاهﺪ ﺷﺪ‪.‬‬ ‫ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﺑﺎ در ﻧﻈﺮ ﮔﺮﻓﺘﻦ ﺑﺰرگ ﻳﺎ آﻮﭼﻚ ﺑﻮدن ﺣﺮوف اﻧﺠﺎم ﻣﻲ ﺷﻮد‪.‬‬ ‫ﺁرﮔﻮﻣﺎن هﺎي ‪ string1‬و ‪ string2‬رﺷﺘﻪ هـﺎﻳﻲ هـﺴﺘﻨﺪ آـﻪ ﺑﺎﻳـﺪ ﺑـﺎ ﻳﻜـﺪﻳﮕﺮ ﻣﻘﺎﻳـﺴﻪ ﺷـﻮﻧﺪ و‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،compare‬روش ﻣﻘﺎﻳﺴﻪ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ‪.NET‬‬ ‫‪٢٢‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .string2 [.Text‬ﺗﻐﻴﻴﺮ دهﻴﺪ‪.‬‬ ‫)] ‪StrComp(string1.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬‬ ‫اﮔﺮ دو رﺷﺘﻪ ﺑﺎ هﻢ ﺑﺮاﺑﺮ ﺑﺎﺷﻨﺪ‪ ،‬ﺗﺎﺑﻊ ﻣﻘﺪار ‪ 0‬را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫”‪str1 =“The quick brown fox jumped over the lazy dog‬‬ ‫”‪str2 =“the‬‬ ‫)‪Pos =InStr(1.‬اﮔـﺮ‬ ‫ذآﺮ ﻧﺸﻮد ‪ 1‬در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد و ﺟﺴﺘﺠﻮ از اﺑﺘﺪاي رﺷﺘﻪ ﺁﻏﺎز ﺧﻮاهﺪ ﺷﺪ‪.‬‬ ‫‪(٢‬ﺟﺴﺘﺠﻮ ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ آﻮﭼﻚ ﻳﺎ ﺑﺰرگ ﺑـﻮدن ﺣـﺮوف اﻧﺠـﺎم ﺧﻮاهـﺪ ﺷـﺪ ﻳﻌﻨـﻲ‬ ‫ﻓﺮﺿﺎ آﻠﻤﺎت ‪ The ،the‬و ‪ THE‬ﺑﺎ هﻢ ﺗﻔﺎوت دارﻧﺪ‪.compare‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬دو رﺷﺘﻪ را ﺑﺎ ﻳﻜﺪﻳﮕﺮ ﻣﻘﺎﻳﺴﻪ آﺮدﻩ و ﺣﺎﺻﻞ ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬‬ ‫)] ‪InStrRev(string1.‬در ﺻــﻮرﺗﻲ آــﻪ ﺁرﮔﻮﻣــﺎن‬ ‫‪ compare‬را ﺑﻪ ‪ CompareMethod.

‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬‬ ‫‪Mid(string. 3‬‬ ‫ﭘﺲ از اﺟﺮاي دﺳﺘﻮرات ﻓـﻮق‪ 3 ،‬آـﺎراآﺘﺮ اول از ﺳـﻤﺖ راﺳـﺖ ﻣﺘﻐﻴـﺮ ‪ StrX‬در ﻣﺘﻐﻴـﺮ ‪StrGet‬‬ ‫ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ و ﻣﻘﺪار ﻣﺘﻐﻴﺮ ‪ ،StrGet‬ﺑﺮاﺑﺮ ﺑﺎ ”‪ “NET‬ﺧﻮاهﺪ ﺷﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ string‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺑﺎﻳﺪ ﺑﺨﺸﻲ از ﺁن ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،string‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺑﺎﻳﺪ رﺷﺘﻪ اي ﺑﻪ ﻃﻮل ﺗﻌﻴﻴﻦ ﺷـﺪﻩ در ﺁرﮔﻮﻣـﺎن ‪number‬‬ ‫از ﺳﻤﺖ ﭼﭗ ﺁن ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد‪.‬‬ ‫ﻣﺜﺎل دﻳﮕﺮ‪:‬‬ ‫)‪Result=StrComp(“Sybex”.‬‬ ‫‪ (٢‬اﮔﺮ از ذآﺮ ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ length‬ﺧﻮدداري ﺷﻮد‪ ،‬ﺗﻤﺎﻣﻲ آﺎراآﺘﺮهﺎ از ﻣﻜﺎﻧﻲ آـﻪ ﺗﻮﺳـﻂ‬ ‫ﺁرﮔﻮﻣﺎن ‪ start‬ﻣﺸﺨﺺ ﺷﺪﻩ ﺗﺎ ﺑﻪ ﺁﺧﺮ رﺷﺘﻪ اﺳﺘﺨﺮاج ﻣﻲ ﺷﻮﻧﺪ‪.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫”‪StrX=”Visual Basic.[length‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﺑﺨﺸﻲ از ﻳﻚ رﺷﺘﻪ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.Text‬‬ ‫اﻳﻦ هﻤﺎن ﻣﺜﺎل ﻗﺒﻠﻲ اﺳﺖ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ در اﻳﻦ ﻣﺜﺎل‪ ،‬ﺑﺰرگ و آﻮﭼﻚ ﺑـﻮدن ﺣـﺮوف ﺗـﺎﺛﻴﺮي در‬ ‫ﻧﺘﻴﺠﻪ ﻣﻘﺎﻳﺴﻪ ﻧﺨﻮاهﺪ داﺷﺖ ﭘﺲ دو رﺷﺘﻪ در اﻳﻦ ﺣﺎل ﺑﺎ ﻳﻜﺪﻳﮕﺮ ﺑﺮاﺑـﺮ ﺑـﻮدﻩ و ﻣﻘـﺪار ‪،Result‬‬ ‫‪ 0‬ﺧﻮاهﺪ ﺷﺪ‪.NET‬‬ ‫‪٢٣‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ . “SYBEX‬‬ ‫ﭘﺲ از اﺟﺮاي اﻳﻦ دﺳﺘﻮر‪ ،‬ﻣﻘﺪار ‪ 1 ،Result‬ﺧﻮاهﺪ ﺷﺪ زﻳـﺮا ﻋﺒـﺎرت ‪ Sybex‬از ‪ SYBEX‬ﺑﺰرﮔﺘـﺮ‬ ‫اﺳﺖ و اﻳﻦ ﺑﺪان ﻋﻠﺖ اﺳﺖ آﻪ در ﺗﺮﺗﻴﺐ ﺣﺮوف اﺳﻜﻲ )‪ ،(ASCII‬ﺣﺮف ‪ y‬آﻮﭼﻚ ﺑﻌﺪ از ﺣﺮف ‪Y‬‬ ‫ﺑﺰرگ ﻗﺮار دارد‪ .start.‬‬ ‫)‪Left(string.length ])=new_string‬‬ ‫در ﺣﺎﻟﺖ ﭘﻴﺸﺮﻓﺘﻪ ﺗﺎﺑﻊ )(‪ Mid‬اﻳﻦ ﺗﺎﺑﻊ وﺟﻮد دارد آﻪ ﺗﺎ ﺣﺪي ﺷﺒﻴﻪ ﺑـﻪ ﺗـﺎﺑﻊ )(‪ Mid‬ﻋﻤـﻞ ﻣـﻲ‬ ‫آﻨﺪ‪. CompareMethod.‬‬ ‫ﻧﻜﺎت ﻣﻬﻢ‪:‬‬ ‫‪ (١‬اﺳﺘﺨﺮاج رﺷﺘﻪ از ﺳﻤﺖ ﭼﭗ ﺑﻪ راﺳﺖ اﻧﺠﺎم ﻣﻲ ﺷﻮد‪.start [.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ start‬ﻣﻜﺎﻧﻲ از رﺷﺘﻪ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ اﺳﺘﺨﺮاج رﺷﺘﻪ ﺑﺎﻳـﺪ از ﺁن ﻣﻜـﺎن ﺷـﺮوع‬ ‫ﺷﻮد و ﺁرﮔﻮﻣﺎن ‪ length‬ﻃﻮل رﺷﺘﻪ ﺑﺮﮔﺸﺘﻲ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ‪.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫”‪StrX=”Visual Basic.NET‬‬ ‫)‪StrGet=Left(StrX.‬‬ ‫‪ (٣‬اﮔﺮ ﻣﻘﺪار ﺁرﮔﻮﻣﺎن ‪ length‬ﺑﻴﺶ از ﺗﻌﺪاد آﺎراآﺘﺮهـﺎﻳﻲ ﺑﺎﺷـﺪ آـﻪ ﺑﻌـﺪ از ﺁرﮔﻮﻣـﺎن ‪ start‬در‬ ‫رﺷﺘﻪ وﺟﻮد دارﻧﺪ‪ ،‬ﺗﻤﺎﻣﻲ آﺎراآﺘﺮهﺎي ﻣﺸﺨﺺ ﺷﺪﻩ در رﺷﺘﻪ‪ ،‬از ﻣﻜـﺎن ‪ Start‬ﺗـﺎ ﺑـﻪ اﻧﺘﻬـﺎ‬ ‫ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،string‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺑﺎﻳﺪ رﺷﺘﻪ اي ﺑﻪ ﻃﻮل ﺗﻌﻴﻴﻦ ﺷـﺪﻩ در ﺁرﮔﻮﻣـﺎن ‪number‬‬ ‫از ﺳﻤﺖ راﺳﺖ ﺁن ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد‪.‬ﺑﻪ ﻋﺒﺎرت دﻳﮕﺮ ﺣﺮوف آﻮﭼﻚ ﺑﺮ ﺣﺮوف ﺑﺰرگ ارﺟﻌﻴﺖ دارﻧﺪ‪.NET‬‬ ‫)‪StrGet=Right(StrX.‫)”‪Result=StrComp(“Sybex”.‬‬ ‫)] ‪Mid(string.number‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬از ﺳﻤﺖ ﭼﭗ ﻳﻚ رﺷﺘﻪ‪ ،‬رﺷﺘﻪ اي ﺑﺎ ﻃﻮل ﻣﻌﻴﻦ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪. 6‬‬ ‫ﭘﺲ از اﺟﺮاي دﺳﺘﻮرات ﻓﻮق‪ 6 ،‬آﺎراآﺘﺮ اول از ﺳﻤﺖ ﭼﭗ ﻣﺘﻐﻴـﺮ ‪ StrX‬در ﻣﺘﻐﻴـﺮ ‪ StrGet‬ﻗـﺮار‬ ‫ﺧﻮاهﺪ ﮔﺮﻓﺖ و ﻣﻘﺪار ﻣﺘﻐﻴﺮ ‪ ،StrGet‬ﺑﺮاﺑﺮ ﺑﺎ ”‪ “Visual‬ﺧﻮاهﺪ ﺷﺪ‪.‬‬ ‫)‪Right(string.number‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬از ﺳﻤﺖ راﺳﺖ ﻳﻚ رﺷﺘﻪ‪ ،‬رﺷﺘﻪ اي ﺑﺎ ﻃﻮل ﻣﻌﻴﻦ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪. “SYBEX”.

‬‬ ‫ﺗﺎﺑﻊ )(‪ ،RTrim‬ﻓﻀﺎي ﺧﺎﻟﻲ ﺳﻤﺖ راﺳﺖ ﻳﻚ رﺷﺘﻪ را ﺣﺬف ﻣﻲ آﻨﺪ‪.NET‬ﺑـﺴﻴﺎر ﺑﻬﺘـﺮ از‬ ‫ﻣﺘﻐﻴﺮهﺎي رﺷﺘﻪ اي )‪ (String‬ﻗﺎدر ﺑﻪ آﺎر ﺑﺎ ﺁﻧﻬﺎﺳﺖ‪) .‬‬ ‫در اﻳﻦ ﺣﺎﻟﺖ ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﺗﻌﺪاد ﺑﺎﻳﺖ هﺎي ﻣـﻮرد ﻧﻴـﺎز ﺟﻬـﺖ ﻧﮕﻬـﺪاري ﻣﻘـﺪار وارد‬ ‫ﺷﺪﻩ در ﺣﺎﻓﻈﻪ ﻣﻲ ﺑﺎﺷﺪ ﻧﻪ ﻃﻮل ﺁن‪.‬‬ ‫‪ (٢‬اﮔﺮ ﺑﺮﻧﺎﻣﻪ اي ﻣﻲ ﻧﻮﻳﺴﻴﺪ آﻪ ﺑﺎ رﺷﺘﻪ هﺎي ﻃﻮﻻﻧﻲ و ﻣﺘﻦ هﺎي زﻳﺎد ﺳـﺮ و آـﺎر دارد ﺣﺘﻤـﺎ‬ ‫از آﻼس ‪ StringBuilder‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.‬‬ ‫ﻣﺜﺎل‪:‬‬ ‫)”‪Name =InputBox(“Enter your first name‬‬ ‫)‪NameLen =Len(Name‬‬ ‫ﺑﻌﺪ از اﺟﺮاي اﻳﻦ دﺳﺘﻮرات‪ ،‬ﻣﻘﺪار ﻣﺘﻐﻴﺮ ‪ ،NameLen‬ﻃـﻮل رﺷـﺘﻪ اي اﺳـﺖ آـﻪ آـﺎرﺑﺮ در آـﺎدر‬ ‫ﻣﺤﺎورﻩ )(‪ InputBox‬وارد آﺮدﻩ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،string‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﻃﻮل ﺁن ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد‪.NET‬ﻣﻘﺎدﻳﺮ اﻋﺸﺎري ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض از ﻧﻮع ‪) Double‬اﻋﺸﺎري ﺑﺎ دﻗـﺖ ﻣـﻀﺎﻋﻒ(‬ ‫در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد ﭘﺲ ﺧﺮوﺟـﻲ ﺗـﺎﺑﻊ در اﻳـﻦ ﺣﺎﻟـﺖ‪ ،‬ﻋـﺪد ‪ 8‬ﻳﻌﻨـﻲ ﺗﻌـﺪاد ﺑﺎﻳـﺖ هـﺎي ﻻزم‬ ‫ﺟﻬﺖ ﻧﮕﻬﺪاري ﻳﻚ ﻣﻘﺪار از ‪ Double‬در ﺣﺎﻓﻈﻪ ﺧﻮاهﺪ ﺑﻮد‪.‬‬ ‫)‪LTrim(string).RTrim(string).NET‬‬ ‫‪٢٤‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.01‬‬ ‫در ‪ ،VB.‬‬ ‫ﻧﻜﺎت ﻣﻬﻢ‪:‬‬ ‫‪ (١‬اﮔﺮ از ذآﺮ ﻣﻘﺪار ‪ new_string‬ﺧﻮدداري ﺷﻮد‪ ،‬ﺗﻤﺎﻣﻲ آﺎراآﺘﺮهـﺎ در رﺷـﺘﻪ از ﻧﻘﻄـﻪ ﺗﻌﻴـﻴﻦ‬ ‫ﺷﺪﻩ در ﺁن ﺗﺎ ﺑﻪ اﻧﺘﻬﺎ ﺟﺎﻳﮕﺰﻳﻦ ﻣﻲ ﺷﻮﻧﺪ‪.‫اﻳﻦ ﺗﺎﺑﻊ رﺷﺘﻪ اي را در ﻳﻚ رﺷﺘﻪ دﻳﮕﺮ ﺟﺎﻳﮕﺰﻳﻦ ﻣﻲ آﻨﺪ‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪:‬‬ ‫‪If Len(Text1.‬‬ ‫از اﻳﻦ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺮاي ﭼـﻚ آـﺮدن اﻳﻨﻜـﻪ ﺁﻳـﺎ آـﺎرﺑﺮ ﻣﻘـﺪاري را در ﻣﻜـﺎﻧﻲ واردﻩ آـﺮدﻩ ﻳـﺎ ﻧـﻪ‪،‬‬ ‫اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.‬‬ ‫ﺗﺎﺑﻊ )(‪ ،LTrim‬ﻓﻀﺎي ﺧﺎﻟﻲ ﺳﻤﺖ ﭼﭗ ﻳﻚ رﺷﺘﻪ را ﺣﺬف ﻣﻲ آﻨﺪ‪.‬‬ ‫و ﺑﻪ ﻋﻨﻮان ﺁﺧﺮﻳﻦ ﻣﺜﺎل‪:‬‬ ‫)‪Len(12‬‬ ‫در اﻳﻦ ﺣﺎﻟﺖ ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ‪ 4 ،‬ﺧﻮاهﺪ ﺑﻮد‪ .‬‬ ‫ﺗﺎﺑﻊ )(‪ Len‬ﻗﺎدر ﺑﻪ درﻳﺎﻓﺖ هﺮ ﻧﻮع ﻣﻘﺪار ﻏﻴﺮ رﺷﺘﻪ اي ﻧﻴﺰ در ﺁرﮔﻮﻣﺎن ‪ string‬ﺧﻮد ﻣﻲ ﺑﺎﺷﺪ‪.‬زﻳﺮا ﻣﻴـﺰان ﻓـﻀﺎي ﻻزم ﺟﻬـﺖ ﻧﮕﻬـﺪاري ﻳـﻚ ﻋـﺪد از‬ ‫ﻧﻮع ‪ 4 ،Integer‬ﺑﺎﻳﺖ اﺳﺖ‪.‬‬ ‫ﻣﺘﻐﻴﺮهﺎي آﻼس ‪ StringBuilder‬از ﻧﻮع ﻣﺘﻨﻲ)‪ (Text‬هﺴﺘﻨﺪ و آﺎﻣﭙـﺎﻳﻠﺮ ‪ .‬آﻼس ﺑﺮﻧﺎﻣﻪ را هﻤﻴﺸﻪ ﺣﻔﻂ آﻨﻴﺪ!(‬ ‫)‪Len(string‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻃﻮل ﻳﻚ رﺷﺘﻪ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪:‬‬ ‫)‪Len(12.Trim(string‬‬ ‫اﻳﻦ ﺗﻮاﺑﻊ‪ ،‬ﻓﻀﺎهﺎي ﺧﺎﻟﻲ ﻳﻚ رﺷﺘﻪ را هﺮ آﺪام ﺑﻪ ﻧﺤﻮي ﺣﺬف ﻣﻲ آﻨﻨﺪ‪.‬‬ ‫ﺗﺎﺑﻊ )(‪ ،Trim‬ﻓﻀﺎي ﺧﺎﻟﻲ ﺳﻤﺖ ﭼﭗ و راﺳﺖ ﻳﻚ رﺷﺘﻪ را ﺣﺬف ﻣﻲ آﻨﺪ‪.Text) = 0 Then‬‬ ‫)”‪MsgBox (“Name field can ’t be empty‬‬ ‫‪Else‬‬ ‫)”‪MsgBox (“Thank you for registering‬‬ ‫‪EndIf‬‬ ‫در اﻳﻦ دﺳﺘﻮرات‪ ،‬ﻣﻘﺪار ‪ TextBox‬ﭼﻚ ﻣﻲ ﺷـﻮد آـﻪ ﺁﻳـﺎ آـﺎرﺑﺮ ﭼﻴـﺰي در ﺁن وارد آـﺮدﻩ ﻳـﺎ ﻧـﻪ و‬ ‫ﺳﭙﺲ ﭘﻴﻐﺎم ﻣﻨﺎﺳﺐ ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ string‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﻣﻘـﺪار ‪ new_String‬ﺑﺎﻳـﺪ در ﺁن ﺟـﺎﻳﮕﺰﻳﻦ ﺷـﻮد و ﺁرﮔﻮﻣـﺎن‬ ‫‪ Start‬ﻣﻮﻗﻌﻴﺘﻲ از ﺁرﮔﻮﻣﺎن )رﺷﺘﻪ( ‪ string‬را ﻣـﺸﺨﺺ ﻣـﻲ آﻨـﺪ آـﻪ ﻋﻤـﻞ ﺟـﺎﻳﮕﺰﻳﻨﻲ ﺑﺎﻳـﺪ از‬ ‫ﺁﻧﺠﺎ ﺷﺮوع ﺷﻮد و ﺁرﮔﻮﻣﺎن ‪ ،length‬ﻃﻮل رﺷﺘﻪ اي را آﻪ ﺑﺎﻳﺪ ﺟﺎﻳﮕﺰﻳﻦ ﺷﻮد ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ‪.

‬‬ ‫آﺎرﺑﺮد اﻳﻦ ﺗﺎﺑﻊ ﻣﻌﻤﻮﻻ در ﭼـﻚ آـﺮدن ﻣﻘـﺎدﻳﺮ ورودي ﺗﻮﺳـﻂ آـﺎرﺑﺮ ﺑـﺮاي ﺗـﺸﺨﻴﺺ ﺧـﺎﻟﻲ ﻧﺒـﻮدن‬ ‫ﻣﻘﺪار ورودي اﺳﺖ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ character‬ﻣﻲ ﺗﻮاﻧﺪ آﺎراآﺘﺮ ﻳﺎ آﺪ اﺳﻜﻲ ﺑﺎﺷﺪ‪.‫ﺁرﮔﻮﻣﺎن ‪ string‬در هﺮ ﺳﻪ ﺗﺎﺑﻊ‪ ،‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﻓﻀﺎي ﺧﺎﻟﻲ ﺁن ﺑﺎﻳﺪ ﺣﺬف ﺷﻮد‪.‬‬ ‫اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ ﺧﺮوﺟﻲ هﺎي ﺑﺮﻧﺎﻣﻪ و اﻳﺠـﺎد ﺑـﺎﻓﺮ ﺑـﺮاي ﺑﺮﺧـﻲ از ﺗﻮاﺑـﻊ‬ ‫‪ API‬ﻣﻔﻴﺪ اﺳﺖ‪.6.‬از ﺁﻧﺠﺎ آـﻪ ‪ Space‬ﻧﻴـﺰ ﻧـﻮﻋﻲ آـﺎراآﺘﺮ اﺳـﺖ ﭘـﺲ دﺳـﺘﻮرات ﺑـﺎﻻ آـﺎرﺑﺮد‬ ‫ﻧﺪارد‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،number‬ﺗﻌﺪاد آﺎراآﺘﺮ ﻓﻀﺎي ﺧﺎﻟﻲ اﺳﺖ آﻪ ﺑﺎﻳﺪ اﻳﺠﺎد ﺷﻮد‪.‬‬ ‫ﻣﻌﻤﻮﻻ ﺗﺎﺑﻊ )(‪ Trim‬از دو ﺗﺎﺑﻊ دﻳﮕﺮ آﺎرﺑﺮد ﺑﻴﺸﺘﺮي دارد‪.conversion‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي را آﻪ ﺑﻪ ﺷﻜﻞ دﻳﮕﺮي ﺗﺒﺪﻳﻞ ﺷﺪﻩ اﺳﺖ ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.‬‬ ‫ﺑﺎ اﺟﺮاي اﻳﻦ دﺳﺘﻮر‪ ،‬آﺎراآﺘﺮ )*( ﺑﻪ ﺗﻌﺪاد ‪ 12‬ﺑﺎر ﺗﻜـﺮار ﺧﻮاهـﺪ ﺷـﺪ و ﻧﺘﻴﺠـﻪ در ﻣﺘﻐﻴـﺮ ‪Result‬‬ ‫ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ‪ .‬‬ ‫ﭘﺲ در اﻳﻦ ﺣﺎﻟﺖ ﺑﺮاي دﻗﺖ ﭼﻚ آﺮدن ﺑﺎﻳﺪ از ﺗﻮاﺑﻊ ﺑﺎﻻ اﺳﺘﻔﺎدﻩ آﺮد‪.NET‬‬ ‫‪٢٥‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .character‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻳﻚ آﺎراآﺘﺮ را در ﻳﻚ رﺷﺘﻪ ﺑﻪ ﺗﻌﺪاد ﻣﻌﻴﻦ ﺑﺎر ﺗﻜﺮار ﻣﻲ آﻨﺪ‪.‬‬ ‫ﻣﺜﻼ دﺳﺘﻮرات زﻳﺮ ﭼﻚ ﻣﻲ آﻨﺪ آﻪ ﺁﻳـﺎ ﻣﻘـﺪار ﻣﺘﻐﻴـﺮ ‪ ،E_Mail‬ﺧـﺎﻟﻲ اﺳـﺖ ﻳـﺎ ﺧﻴـﺮ و در ﺻـﻮرت‬ ‫ﺧﺎﻟﻲ ﺑﻮدن ﺁن ﭘﻴﻐﺎﻣﻲ ﻇﺎهﺮ ﻣﻲ ﮔﺮدد‪.‬‬ ‫)‪StrDup(number.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،string‬رﺷﺘﻪ اي اﺳـﺖ آـﻪ ﺑﺎﻳـﺪ ﺗﺒـﺪﻳﻞ ﺷـﻮد و ﺁرﮔﻮﻣـﺎن ‪ conversion‬ﻧـﻮع ﺗﺒـﺪﻳﻞ را‬ ‫ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ ﻣﻲ ﺗﻮاﻧﺪ ﻳﻜﻲ از ﻣﻮارد زﻳﺮ ﺑﺎﺷﺪ‪:‬‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ convesion‬در ﺗﺎﺑﻊ )(‪StrConv‬‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻣﻘﺪار‬ ‫ﺗﻤﺎﻣﻲ آﺎراآﺘﺮهﺎي ﻣﻮﺟﻮد در رﺷﺘﻪ ﺑـﻪ ﺣـﺮوف‬ ‫‪UpperCase‬‬ ‫ﺑﺰرگ ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬ ‫ﭘﺲ دﺳﺘﻮرات ﺑﺎﻻ را ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺻﻼح ﻣﻲ آﻨﻴﻢ‪:‬‬ ‫‪If Trim(E_Mail)=“” Then‬‬ ‫)”!‪MsgBox (“Invalid Entry‬‬ ‫‪End If‬‬ ‫)‪Space(number‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻳﻚ رﺷﺘﻪ آﺎراآﺘﺮي از ﻓﻀﺎي ﺧﺎﻟﻲ )‪ (Blanck‬اﻳﺠﺎد ﻣﻲ آﻨﺪ‪.0‬ﺷﺪﻩ اﺳﺖ‪.‬‬ ‫‪If E_Mail = “” Then‬‬ ‫)”‪MsgBox (“Applications without an e-mail address won ’t be processed‬‬ ‫‪End If‬‬ ‫ﺣﺎل در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ آﻪ آﺎرﺑﺮ ﺑﻪ ﺟﺎي ﺗﺎﻳﭗ آﺎراآﺘﺮي در ﻣﻜﺎن ﻣﻮرد ﻧﻈﺮ‪،‬ﻳﻚ ﻳـﺎ ﭼﻨـﺪﻳﻦ ﺑـﺎر از آﻠﻴـﺪ‬ ‫‪ Space‬اﺳﺘﻔﺎدﻩ آﻨﺪ‪ .‬ﻳﻌﻨﻲ ﻣﺘﻐﻴﺮ ‪ Result‬داراي ﻣﻘﺪار زﻳﺮ ﺧﻮاهﺪ ﺷﺪ‪:‬‬ ‫”************”=‪Result‬‬ ‫)‪StrConv(string.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫)”*“ ‪Result=StrDup(12.‬‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ هﺮ ﺳﻪ ي اﻳﻦ ﺗﻮاﺑﻊ‪ ،‬ﻣﻘﺪاري رﺷﺘﻪ اي و از ﻧـﻮع ‪ String‬ﻣـﻲ ﺑﺎﺷـﺪ و ﻋﺒـﺎرﺗﻲ‬ ‫اﺳﺖ آﻪ ﻓﻀﺎهﺎي ﺧﺎﻟﻲ ﺁن ﺑﻨﺎ ﺑﻪ ﻧﻮع ﺗﺎﺑﻊ‪ ،‬ﺣﺬف ﺷﺪﻩ اﺳﺖ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ number‬ﻋﺪدي اﺳﺖ آﻪ ﺗﻌـﺪاد ﺗﻜـﺮار آـﺎراآﺘﺮ را آـﻪ ﺑـﻪ وﺳـﻴﻠﻪ ﺁرﮔﻮﻣـﺎن ‪character‬‬ ‫ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد‪ ،‬ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ‪.‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺟﺎﻳﮕﺰﻳﻦ ﺗﺎﺑﻊ )(‪ String‬در ‪ VB.‬‬ ‫ﺗﻤﺎﻣﻲ آﺎراآﺘﺮهﺎي ﻣﻮﺟﺪ در رﺷـﺘﻪ ﺑـﻪ ﺣـﺮوف‬ ‫‪LowerCase‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.

NET‬‬ ‫‪٢٦‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﺑﻪ ﻣﺜﺎل زﻳﺮ ﺗﻮﺟﻪ آﻨﻴﺪ‪:‬‬ ‫)‪newString =StrConv(MyString.‬‬ ‫آﺎراآﺘﺮهــﺎي ﺳــﻨﺘﻲ ﭼﻴﻨــﻲ ﺑــﻪ آﺎراآﺘﺮهــﺎي‬ ‫ﺳﺎدﻩ ﭼﻴﻨﻲ ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ‬ ‫ﺑﺮاي ﺗﺒﺪﻳﻞ هﺎي ﭼﻨﺪﺗﺎﻳﻲ ﻣﻲ ﺗﻮاﻧﻴﺪ اﻳﻦ ﻣﻘﺎدﻳﺮ را ﺑﺎ ﻋﻼﻣﺖ ‪ +‬ﺑﺎ هﻢ ‪ AND‬آﻨﻴﺪ‪.‬‬ ‫دو ﺁرﮔﻮﻣﺎن ﺁﺧﺮ‪ ،‬اﺧﺘﻴﺎري هﺴﺘﻨﺪ‪.‫‪ProperCase‬‬ ‫‪Wide Narrow‬‬ ‫‪Narrow‬‬ ‫‪Katakana‬‬ ‫‪Hiragana‬‬ ‫‪Traditional‬‬ ‫‪Simplified‬‬ ‫آﻮﭼﻚ ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ‪.Unicode‬‬ ‫در اﻳﻦ دﺳﺘﻮر‪ ،‬ﻋﺒﺎرت ﻣﻮﺟﻮد در ﻣﺘﻐﻴـﺮ ‪ ،MyString‬ﺑـﻪ ﺣـﺮوف آﻮﭼـﻚ و ﻗﺎﻟـﺐ ‪ Unicode‬ﺗﺒـﺪﻳﻞ‬ ‫ﺧﻮاهﺪ ﺷﺪ‪.compare‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺑﻴﺎن ﺳﺎدﻩ ﻳﻚ رﺷﺘﻪ ﻳﺎ زﻳﺮرﺷﺘﻪ را در ﻳﻚ ﺁراﻳﻪ رﺷـﺘﻪ اي ﺟـﺴﺘﺠﻮ آـﺮدﻩ و در ﺻـﻮرت‬ ‫ﭘﻴﺪا آﺮدن ﺁن‪ ،‬ﻳﻚ ﺁراﻳﻪ را ﺑﻪ ﻋﻨﻮان ﺧﺮوﺟﻲ ﻣﻲ دهﺪ آﻪ ﺧﺎﻧﻪ ﻳﺎ ﺧﺎﻧﻪ هﺎي ﺁن ﺗﺎ اﻧﺪﻳﺲ ﻣﻘﺪاري‬ ‫آﻪ در ﺁراﻳﻪ اﺻﻠﻲ ﭘﻴﺪا ﺷﺪﻩ و ﺑﺎ ﺁن ﻣﻘﺪار ﭘﺮ ﻣﻲ ﺷﻮد‪.LowerCase + vbStrConv.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،compare‬ﻧﻮع ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ و ﻣـﺸﺨﺺ ﻣـﻲ آﻨـﺪ آـﻪ ﺁﻳـﺎ ﺑـﺰرگ ﻳـﺎ‬ ‫آﻮﭼــﻚ ﺑــﻮدن ﺣــﺮوف ﺗــﺎﺛﻴﺮي در ﻣﻘﺎﻳــﺴﻪ و ﺟــﺴﺘﺠﻮ داﺷــﺘﻪ ﺑﺎﺷــﺪ ﻳــﺎ ﺧﻴــﺮ و ﻳﻜــﻲ از ﻣﻘــﺎدﻳﺮ‬ ‫‪) CompareMethod.‬ﻓﺮﺿﺎ اﮔﺮ ﻣﻘﺪار ﻣﻮرد ﻧﻈﺮ ﻣﺎ در ﺧﺎﻧﻪ ي ‪ 4‬ﺁراﻳﻪ ﭘﻴـﺪا ﺷـﺪ‪ ،‬ﺗﻌـﺪاد ﺧﺎﻧـﻪ هـﺎي‬ ‫ﺁراﻳﻪ ﺑﺮﮔﺸﺘﻲ ‪ 4‬ﺧﺎﻧﻪ ﺧﻮاهﺪ ﺑﻮد‪.‬‬ ‫آﺎراآﺘﺮهﺎي ﺗﻚ ﺑﺎﻳﺘﻲ در رﺷﺘﻪ ﺑﻪ آﺎراآﺘﺮهـﺎي‬ ‫دوﺑﺎﻳﺘﻲ ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ‬ ‫آﺎراآﺘﺮهﺎي دوﺑﺎﻳﺘﻲ در رﺷـﺘﻪ ﺑـﻪ آﺎراآﺘﺮهـﺎي‬ ‫ﺗﻚ ﺑﺎﻳﺘﻲ ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬ ‫آﺎراآﺘﺮهــــﺎي ‪ Katakana‬ﺑــــﻪ آﺎراآﺘﺮهــــﺎي‬ ‫‪ Hiragana‬ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ‪.Text‬ﻳﻌﻨﻲ در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻧﻤﻲ ﺷﻮد( را ﻣﻲ ﭘﺬﻳﺮد‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ value‬ﻣﻘﺪاري رﺷﺘﻪ اي اﺳﺖ آﻪ ﺟﺴﺘﺠﻮ ﺑﺎﻳﺪ ﺑﺮاي ﺁن اﻧﺠﺎم ﺷﻮد‪.include ][.‬‬ ‫در ﺣﻘﻴﻘﺖ ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ آﻪ در ﺁراﻳﻪ ﻗﺮار ﻣﻲ ﮔﻴـﺮد‪ ،‬ﺷـﺎﻣﻞ ﻳﻜـﻲ از ﻣﻘـﺎدﻳﺮ ﺧﺎﻧـﻪ هـﺎي ﺁراﻳـﻪ‬ ‫ﺟﺴﺘﺠﻮ ﺷﻮﻧﺪﻩ اﺳﺖ‪.‬‬ ‫)‪StrReverse(string‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي را ﻣﻌﻜﻮس ﻣﻲ آﻨﺪ‪.‬‬ ‫)] ‪Filter(inputStrings.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬‬ ‫اوﻟﻴﻦ آﺎراآﺘﺮ هﺮ آﻠﻤﻪ در رﺷﺘﻪ ﺑﻪ ﺣﺮف ﺑـﺰرگ‬ ‫ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮد‪.‬‬ ‫ﺗﻌﺪاد ﺧﺎﻧﻪ هﺎي ﺁراﻳﻪ ي ﺑﺮﮔﺸﺖ دادﻩ ﺷﺪﻩ ﺑﺴﺘﮕﻲ ﺑﻪ اﻧﺪﻳﺲ ﻣﺤﻞ وﺟﻮد رﺷﺘﻪ اي اﺳـﺖ آـﻪ‬ ‫در ﺁراﻳﻪ ﭘﻴﺪا ﺷﺪﻩ‪ .‬‬ ‫آﺎراآﺘﺮهـــــﺎي ‪ Hiragana‬ﺑـــــﻪ آﺎراآﺘﺮهـــــﺎي‬ ‫‪ Katakana‬ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ‪. vbStrConv.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ include‬ﻣﺸﺨﺺ ﻣﻲ آﻨﻪ آﻪ ﺁﻳﺎ آﻞ ﻣﻘﺪار ‪ value‬ﺑﺎﻳﺪ در ﺁراﻳﻪ ﺑﺎﺷﺪ ﻳـﺎ ﻗـﺴﻤﺘﻲ از ﺁن‬ ‫هﻢ ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ ﻋﻨﻮان ﺷﺮط ﺟﺴﺘﺠﻮ ﺑﻪ آﺎر رود و ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ ‪ True‬ﻳﺎ ‪ False‬را ﻣﻲ ﭘﺬﻳﺮد‪.‬‬ ‫آﺎراآﺘﺮهـــﺎي ﺳـــﺎدﻩ ﭼﻴﻨـــﻲ ﺑـــﻪ آﺎراآﺘﺮهـــﺎي‬ ‫ﺳﻨﺘﻲ ﭼﻴﻨﻲ ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ‪.Binary‬ﭘــــﻴﺶ ﻓــــﺮض ﻳﻌﻨــــﻲ در ﻧﻈــــﺮ ﮔﺮﻓﺘــــﻪ ﻣــــﻲ ﺷــــﻮد( و ﻳــــﺎ‬ ‫‪) CompareMethod.‬‬ ‫ﻣﺜﺎل‪:‬‬ ‫)”‪Result=StrReverse(“VisualBasic‬‬ ‫ﭘﺲ از اﺟﺮاي اﻳﻦ دﺳﺘﻮر‪ ،‬ﻣﻘﺪار ﻣﺘﻐﻴﺮ ‪ Result‬ﺑﺮاﺑﺮ ﺑﺎ ”‪ “lausiVcisaB‬ﺧﻮاهﺪ ﺷﺪ‪.‬دﻗﺖ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ اﻳﻦ ﺁراﻳﻪ ﺣﺘﻤﺎ ﺑﺎﻳﺪ ﺑﻪ ﺻﻮرت ﻳﻚ ﺑﻌﺪي ﺗﻌﺮﻳﻒ ﺷﻮد‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،inputstring‬ﻳﻚ ﺁراﻳﻪ ﻳﻚ ﺑﻌﺪي و رﺷﺘﻪ اي اﺳﺖ آﻪ ﻋﻤﻞ ﺟﺴﺘﺠﻮ ﺑﺎﻳـﺪ در ﺁن اﻧﺠـﺎم‬ ‫ﺷﻮد‪ .value [.

“bes‬‬ ‫)‪Console.start ][.‬‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،start‬ﻋﺪدي اﺳﺖ آﻪ ﻣﻜﺎن ﺷﺮوع ﺟﺴﺘﺠﻮ در رﺷﺘﻪ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨـﺪ و اﮔـﺮ‬ ‫در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻧﺸﻮد‪ ،‬ﺟﺴﺘﺠﻮ از اﺑﺘﺪاي رﺷﺘﻪ ﺷﺮوع ﻣﻲ ﺷﻮد‪.bes as powerfull as C#. “Mehdi”.NET as powerfull as C#.‬اﻳﻦ ﺁراﻳﻪ اي اﺳﺖ آﻪ ﻣﺎ در ﺁن ﻗﺼﺪ ﺟﺴﺘﺠﻮي ﻣﻘﺪار ﺧﻮد را دارﻳﻢ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،list‬ﺁراﻳﻪ اي ﻳﻚ ﺑﻌﺪي و ﺷﺎﻣﻞ ﻣﻘﺎدﻳﺮي رﺷﺘﻪ اي اﺳـﺖ آـﻪ ﻗـﺼﺪ ﺑﺎزﮔـﺸﺖ ﺁﻧﻬـﺎ ﺑـﻪ‬ ‫ﺻﻮرت ﻳﻚ رﺷﺘﻪ را دارﻳﺪ و ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،delimiter‬ﻳﻚ آـﺎراآﺘﺮ رﺷـﺘﻪ اي اﺳـﺖ آـﻪ ﺑـﺮاي‬ ‫ﺟﺪا آﺮدن رﺷﺘﻪ هﺎ از هﻢ در ﻧﺘﻴﺠﻪ ﺧﺮوﺟﻲ ﺑـﻪ آـﺎر ﻣـﻲ رود و در ﺻـﻮرﺗﻲ آـﻪ ذآـﺮ ﻧـﺸﻮد‪ ،‬ﻳـﻚ‬ ‫ﻓﺎﺻﻠﻪ ﺧﺎﻟﻲ در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد و اﮔﺮ ﻣﻘﺪار ﺁن ﺗﻬﻲ ﻳﺎ ”“ ﺗﻌﻴﻴﻦ ﺷـﻮد‪ ،‬ﻣﻘـﺎدﻳﺮ ﺧﺎﻧـﻪ هـﺎي‬ ‫ﺁراﻳﻪ ﭘﺸﺖ ﺳﺮ هﻢ و ﺑﺪون ﻓﺎﺻﻠﻪ در ﺧﺮوﺟﻲ ﻇﺎهﺮ ﺧﻮاهﻨﺪ ﺷﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،replacewith‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺟﺎﻳﮕﺰﻳﻦ رﺷﺘﻪ ﭘﻴﺪا ﺷﺪﻩ ﻣﻲ ﺷﻮد‪. “NET”. “Behrouz”.WriteLn(K‬‬ ‫ﺧﺮوﺟﻲ اﻳﻦ ﻗﻄﻌﻪ ﺑﺮﻧﺎﻣﻪ ﭘﺲ از اﺟﺮا ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺧﻮاهﺪ ﺑﻮد‪:‬‬ ‫”‪”Visual Basic.NET‬‬ ‫)”‪K=Replace (S.replacewith [.myName‬‬ ‫ﭘﺲ از اﺟﺮاي اﻳﻦ دﺳـﺘﻮر اﮔـﺮ ﻣﻘـﺪار ذﺧﻴـﺮﻩ ﺷـﺪﻩ در ﻣﺘﻐﻴـﺮ ‪ myName‬در ﺁراﻳـﻪ ﻧﺒﺎﺷـﺪ‪ ،‬در ﺁن‬ ‫ﺻﻮرت ﺁراﻳﻪ ‪ selNames‬آﻪ ﺁن را ﺑﻪ ﺻﻮرت ﺁراﻳﻪ اي ﺑﺪون ﺑﻌﺪ ﺗﻌﺮﻳﻒ آﺮدﻳﻢ ﺁراﻳﻪ اي ﺑـﺪون ﺧﺎﻧـﻪ‬ ‫ﺧﻮاهﺪ ﺑﻮد و ﻳﺎ ﺑﻪ ﻋﺒﺎرت دﻳﮕﺮ ﺧﺎﺻﻴﺖ ‪ Length‬ﺁن ﺑﺮاﺑﺮ ﺑﺎ ‪ 0‬ﺧﻮاهﺪ ﺑﻮد‪.‬اﮔﺮ ذآﺮ ﻧﺸﻮد‪ ،‬آﻠﻴﻪ ﺟﺎﻳﮕﺰﻳﻨﻲ هﺎ اﻧﺠﺎم ﺧﻮاهﺪ ﺷﺪ‪.count ][.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫‪Dim selNames()As String‬‬ ‫}”‪Dim Names()As String ={“Ali”.‬‬ ‫اﮔﺮ ﻣﻘﺪار ذﺧﻴـﺮﻩ ﺷـﺪﻩ در ﻣﺘﻐﻴـﺮ ‪ “Ali” ،myName‬ﺑﺎﺷـﺪ‪ ،‬ﺣـﺪ ﺑـﺎﻻي ﺁراﻳـﻪ ‪ selNames‬ﺻـﻔﺮ‬ ‫ﺧﻮاهﺪ ﺑﻮد و ﻣﻘﺪار اوﻟﻴﻦ ﺧﺎﻧﻪ ﺁراﻳﻪ ﺑﺮاﺑﺮ ﺑﺎ ”‪ “Ali‬ﻣﻲ ﺷﻮد ﻳﻌﻨﻲ‪selNames(0)=”Ali” :‬‬ ‫اﮔﺮ ﻣﻘﺪار ذﺧﻴﺮﻩ ﺷﺪﻩ در ﻣﺘﻐﻴﺮ ‪ “Mehdi” ،myName‬ﺑﺎﺷﺪ‪ ،‬ﺣﺪ ﺑـﺎﻻي ﺁراﻳـﻪ ‪ ،selNames‬ﻳـﻚ‬ ‫ﺧﻮاهﺪ ﺑﻮد و ﻣﻘﺎدﻳﺮ ﺧﺎﻧﻪ هﺎي اول و دوم ﺁراﻳﻪ ﺑﺮاﺑﺮ ﺑﺎ ”‪ “Mehdi‬ﻣﻲ ﺷﻮد ﻳﻌﻨﻲ‪:‬‬ ‫”‪selNames(0)=”Mehdi‬‬ ‫”‪selNames(1)=”Mehdi‬‬ ‫)] ‪Replace(expression.‫ﭘﺲ‪ ،‬از ﺁﻧﺠﺎ آﻪ ﺧﺎﻧﻪ اي آﻪ ﻣﻘﺪار ﻣﻮرد ﻧﻈﺮ در ﺁن ﭘﻴﺪا ﻣﻲ ﺷﻮد از ﻗﺒﻞ ﻗﺎﺑﻞ ﭘﻴﺶ ﺑﻴﻨﻲ ﻧﻴـﺴﺖ‬ ‫ﻧﺒﺎﻳﺪ ﺑﺮاي ﺧﺎﻧﻪ هﺎي ﺁراﻳﻪ ﺑﺮﮔﺸﺘﻲ‪ ،‬ﺗﻌﺪاد ﺗﻌﺮﻳﻒ آﻨﻴﻢ و ﻳﺎ ﺑﻪ ﻋﺒﺎرت دﻳﮕـﺮ ﺑﺎﻳـﺪ ﻳـﻚ ﺁراﻳـﻪ ﺑـﺪون‬ ‫ﺑﻌﺪ ﺗﻌﺮﻳﻒ آﻨﻴﻢ‪.bes‬‬ ‫)] ‪Join(list [. “Sina‬‬ ‫در اﻳﻦ ﻣﺜﺎل‪ ،‬ﺁراﻳﻪ اي ﺑﻪ ﻧﺎم ‪ Names‬ﺗﻌﺮﻳﻒ ﺷﺪﻩ آﻪ ﭘﻨﺞ ﺧﺎﻧﻪ ي اول ﺁن ﺑﺎ ‪ 5‬ﻣﻘـﺪار رﺷـﺘﻪ اي‬ ‫ﭘﺮ ﺷﺪﻩ اﺳﺖ‪ . “Mehdi”.compare‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻳﻚ رﺷﺘﻪ را در رﺷﺘﻪ دﻳﮕـﺮ ﺟـﺴﺘﺠﻮ آـﺮدﻩ و رﺷـﺘﻪ ﺳـﻮم را ﺟـﺎﻳﮕﺰﻳﻦ رﺷـﺘﻪ ﺟـﺴﺘﺠﻮ‬ ‫ﺷﺪﻩ ﻣﻲ آﻨﺪ‪.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫”‪S=”Visual Basic.find.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺑﺮاي ﺟﺎﻳﮕﺰﻳﻨﻲ ﺟﺴﺘﺠﻮ ﻣﻲ ﮔﺮدد‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،count‬ﻣﻘﺪاري ﻋﺪدي اﺳﺖ آﻪ ﺗﻌﺪاد دﻓﻌﺎﺗﻲ را آﻪ ﺟﺎﻳﮕﺰﻳﻨﻲ ﺑﺎﻳﺪ اﻧﺠﺎم ﮔﻴﺮد‪ ،‬ﺗﻌﻴـﻴﻦ‬ ‫ﻣﻲ آﻨﺪ‪ .‬‬ ‫و در ﻧﻬﺎﻳﺖ ﺁرﮔﻮﻣﺎن ‪ ،compare‬ﻧﻮع ﻣﻘﺎﻳﺴﻪ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آـﻪ در ﺗﻮاﺑـﻊ ﻗﺒﻠـﻲ در ﻣـﻮرد اﻳـﻦ‬ ‫ﺁرﮔﻮﻣﺎن ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪ‪.‬ﭘﺲ ﺗﺎﺑﻊ )(‪ Filter‬را ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ آﻨﻴﻢ‪:‬‬ ‫)‪selNames =Filter(Names.delimiter‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻣﻘﺎدﻳﺮ ﻣﻮﺟﻮد در ﻳﻚ ﺁراﻳﻪ ﻳﻚ ﺑﻌﺪي – رﺷﺘﻪ اي را ﺑﻪ ﺻﻮرت ﻳﻚ رﺷﺘﻪ و ﭘﺸﺖ ﺳﺮ هﻢ‬ ‫ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.NET‬‬ ‫‪٢٧‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،find‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺟﺴﺘﺠﻮ ﻣﻲ ﮔﺮدد‪.‬‬ ‫ﺣﺎل ﻣﻲ ﺧﻮاهﻴﻢ ﻣﻘﺪار ذﺧﻴـﺮﻩ ﺷـﺪﻩ در ﻣﺘﻐﻴـﺮي رﺷـﺘﻪ اي ﺑـﻪ ﻧـﺎم ‪ myName‬را در اﻳـﻦ ﺁراﻳـﻪ‬ ‫ﺟﺴﺘﺠﻮ آﻨﻴﻢ‪ .‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫‪Dim MyArr(1 To 5) As String‬‬ ‫‪Dim Result As String‬‬ ‫”‪MyArr(1) = "Behrouz‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.

‬‬ ‫‪MsgBox Result‬‬ ‫ﺑﻌﺪ از اﺟﺮاي اﻳﻦ دﺳﺘﻮرات‪ ،‬ﺧﺮوﺟﻲ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ‪:‬‬ ‫”|||‪“Behrouz|Rad‬‬ ‫دﻗﺖ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ اﮔﺮ ﺗﻤﺎم ﺧﺎﻧﻪ هﺎي ﺁراﻳﻪ ﭘﺮ ﻧﺸﺪﻩ ﺑﺎﺷﻨﺪ‪ ،‬ﺑﻪ ﺟـﺎي ﺁﻧﻬـﺎ آـﺎراآﺘﺮي آـﻪ در‬ ‫ﺁرﮔﻮﻣﺎن ‪ delimiter‬ﺗﻌﻴﻴﻦ ﺷﺪﻩ ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ‪.compare‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻳﻚ رﺷﺘﻪ را ﺑﻪ ﺗﻌﺪادي زﻳﺮرﺷﺘﻪ ي آﻮﭼﻜﺘﺮ ﺗﻘﺴﻴﻢ آﺮدﻩ و هﺮ آﺪام را در ﻳﻜﻲ از ﺧﺎﻧـﻪ‬ ‫هﺎي ﺁراﻳﻪ ﻗﺮار ﻣﻲ دهﺪ و ﻳﺎ ﺑﻪ ﻋﺒﺎرت ﺑﻬﺘﺮ هﺮ آﺪام از آﻠﻤﺎت رﺷﺘﻪ را در ﻳﻚ ﺧﺎﻧﻪ ي ﺁراﻳـﻪ ﻗـﺮار‬ ‫ﻣﻲ دهﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ compare‬آﻪ ﻧﻮع ﻣﻘﺎﻳﺴﻪ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ در ﺗﻮاﺑﻊ ﻗﺒﻠﻲ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪ‪.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫ﻓﺮض ﻣﻲ آﻨﻴﻢ ﻣﺘﻐﻴﺮي رﺷﺘﻪ اي ﺑﻪ ﻧﺎم ‪ path‬ﺗﻌﺮﻳﻒ آﺮدﻩ اﻳﻢ آﻪ ﻣﻘـﺪار زﻳـﺮ در ﺁن ﻗـﺮار ﮔﺮﻓﺘـﻪ‬ ‫اﺳﺖ‪:‬‬ ‫”‪path =“c:\win\desktop\DotNet\Examples\Controls‬‬ ‫ﺗﺎﺑﻊ )(‪ Split‬در اﻳﻦ ﺣﺎﻟﺖ ﻣﻲ ﺗﻮاﻧﺪ هﺮ ﻳﻚ اﺟـﺰاي اﻳـﻦ ﻣﻘـﺪار را آـﻪ ﺑـﺎ آـﺎراآﺘﺮ )\( از هـﻢ ﺟـﺪا‬ ‫ﺷﺪﻩ اﻧﺪ ﺑﺎ دﺳﺘﻮر زﻳﺮ ﺟﺪا آﺮدﻩ و در ﺧﺎﻧﻪ هﺎي ﻳﻚ ﺁراﻳﻪ ﺑﻪ ﻧﺎم ‪ parts‬ﻗﺮار دهﺪ‪:‬‬ ‫)”\“‪parts =Split(“c:\win \desktop \DotNet \Examples \Controls ”.count ][.GetUpperBound(0‬‬ ‫))‪Console.delimiter ][.‬‬ ‫ﺧﺮوﺟﻲ اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻳﻚ ﺁراﻳﻪ ﻳﻚ ﺑﻌﺪي اﺳﺖ آﻪ هـﺮ آـﺪام از ﺧﺎﻧـﻪ هـﺎي ﺁن داراي ﻳﻜـﻲ از ﻣﻘـﺎدﻳﺮ‬ ‫زﻳﺮرﺷﺘﻪ هﺎﺳﺖ‪.‫”‪MyArr(2) = "Rad‬‬ ‫)”|“ ‪Result = Join(MyArr.WriteLine(parts(i‬‬ ‫‪Next‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،delimiter‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺗﻘﺴﻴﻢ ﺑﻨﺪي ﺑﺎﻳﺪ ﺑـﺮ اﺳـﺎس ﺁن اﻧﺠـﺎم ﺷـﻮد‪.‬‬ ‫اﮔﺮ ﻣﻘﺪار ﺁن ‪ –1‬ﺑﺎﺷﺪ‪ ،‬ﺗﻤﺎﻣﻲ زﻳﺮرﺷﺘﻪ هﺎ ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﻨﺪ ﺷﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺑﺎﻳﺪ ﺑﻪ زﻳﺮرﺷﺘﻪ هﺎي آﻮﭼﻜﺘﺮ ﺗﻘﺴﻴﻢ ﺷﻮد‪.‬‬ ‫ﺣﺎل ﺑﺎ دﺳﺘﻮرات زﻳﺮ ﻣﻲ ﺗﻮاﻧﻴﻢ ﻧﺘﻴﺠﻪ آﺎر را ﻣﺸﺎهﺪﻩ آﻨﻴﻢ‪:‬‬ ‫)‪For i =0 To parts.‬‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ count‬ﻧﻴﺰ ﺗﻌﺪاد زﻳﺮرﺷﺘﻪ هﺎﻳﻲ را آﻪ ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷـﻮﻧﺪ ﻣـﺸﺨﺺ ﻣـﻲ‬ ‫آﻨﺪ‪.NET‬‬ ‫‪٢٨‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫اﮔﺮ ذآﺮ ﻧﺸﻮد ﻓﻀﺎي ﺧﺎﻟﻲ در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد وﻟﻲ اﮔﺮ ﺗﻬﻲ ﻳﺎ ”“ ذآﺮ ﺷﻮد‪ ،‬آﻞ رﺷـﺘﻪ در‬ ‫اوﻟﻴﻦ ﻋﻨﺼﺮ ﺁراﻳﻪ ﻗﺮار ﻣﻲ ﮔﻴﺮد‪.‬‬ ‫ﺗﻌﺪاد آﺎراآﺘﺮهﺎي ‪ delimiter‬آﻪ ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ‪ ،‬ﺗﻌﺪاد ﺧﺎﻧﻪ هﺎي ﺁراﻳﻪ ﻣﻨﻬﺎي ﻳﻚ اﺳﺖ‪.‬‬ ‫)] ‪Split(expression [.

firstdayofweek [.‬‬ ‫)‪Console.“$###.Atan(1)*4.‬‬ ‫ﻣﻲ ﺧﻮاهﻴﻢ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ ،Format‬ﻋﻼﻣﺖ )‪ ($‬در اﺑﺘﺪاي ﻧﺘﻴﺠﻪ ﻇﺎهﺮ و هﻤﭽﻨـﻴﻦ ﻣﻴـﺰان‬ ‫ﺧﺮدﻩ ي ﭘﻮل ﺑﻪ دﺳﺖ ﺁﻣﺪﻩ ﻓﻘﻂ ﺗﺎ دو رﻗﻢ ﺣﺴﺎب ﺷﻮد‪ .454.‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﻣﻘﺪار را ﺑﺎ ﻓﺮﻣﺖ ﺧﺎﺻﻲ ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔـﺮ ﻣﻘـﺪار ورودي ﻣـﺎ ﻳﻌﻨـﻲ ﻣﻘـﺪار ﺁرﮔﻮﻣـﺎن ‪ expression‬از ﻧـﻮع زﻣـﺎن )‪(Time‬‬ ‫ﺑﺎﺷﺪ و ﻗﺎﻟﺐ ﺁرﮔﻮﻣﺎن ‪ format‬را ﺑﻪ ﺷﻜﻞ ”‪ “hh:mm:ss‬اﻧﺘﺨﺎب آﺮدﻩ ﺑﺎﺷـﻴﻢ‪ ،‬ﺧﺮوﺟـﻲ ﺗـﺎﺑﻊ‪،‬‬ ‫زﻣﺎن ﺣﺎل را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪ .format [.‬‬ ‫ﺑﻪ ﺑﻴﺎن ﺳﺎدﻩ‪ ،‬اﻳﻦ ﺗﺎﺑﻊ ﺷﻴﻮﻩ ﻧﻤﺎﻳﺶ اﻋﺪاد‪ ،‬رﺷﺘﻪ هـﺎ و ﻣﻘـﺎدﻳﺮ ﺗـﺎرﻳﺦ و زﻣـﺎن را ﻣـﺸﺨﺺ ﻣـﻲ‬ ‫آﻨﺪ‪.‬ﭘﺲ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ‪:‬‬ ‫‪amount =13454.‬ﻣﺜﻼ‪“18:22:37” :‬‬ ‫ﺑـﻪ ﻋﻨــﻮان ﻣﺜــﺎﻟﻲ دﻳﮕــﺮ‪ ،‬ﻓﺮﻣــﺎن زﻳــﺮ ‪ ،‬ﻣﻘــﺪار ‪ pi‬را ﺑـﻪ ﺷــﻜﻞ ﻋــﺪدي اﻋــﺸﺎري ﺑــﺎ دﻗــﺖ ﻣــﻀﺎﻋﻒ‬ ‫)‪ (Double‬ﻣﺤﺎﺳﺒﻪ ﻣﻲ آﻨﺪ‪.Atan(1)*4‬‬ ‫ﻧﺘﻴﺠﻪ ﺧﺮوﺟﻲ‪ ،‬ﻋﺪد ”‪ “3.454.####‬‬ ‫اﻳﻦ دﺳﺘﻮر ﻧﺘﻴﺠﻪ ﺧﺮوﺟﻲ را ﺑﻪ ﺷﻜﻞ ‪ 3.6.NET‬ﺗﻤــﺎﻣﻲ ﺗــﻮاﺑﻌﻲ آــﻪ در ‪ VB.‬‬ ‫ﻓﺮض آﻨﻴﺪ آﻪ ﻋﺪد ‪ 13.332345201‬‬ ‫))”‪Console.0‬ﺑــﺮاي ﻗﺎﻟــﺐ دهــﻲ ﺑــﻪ دادﻩ هــﺎ ﺑــﻪ آــﺎر ﻣــﻲ روﻧــﺪ را‬ ‫ﭘﺸﺘﻴﺒﺎﻧﻲ ﻣﻲ آﻨﺪ‪. “##.‬ﭘﺲ از ﺗﺎﺑﻊ )(‪ Format‬ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺘﻔﺎدﻩ ﻣﻲ آﻨﻴﻢ‪:‬‬ ‫))”‪Console.‬‬ ‫ﻣﺜﺎل دﻳﮕﺮ‪ :‬ﻓﺮض آﻨﻴﻢ آﻪ ﺷﻤﺎ ﺑﻪ ﻋﻨﻮان ﻳـﻚ ﺣـﺴﺎﺑﺪار در ﻳـﻚ ﺑﺎﻧـﻚ ﻣـﺸﻐﻮل ﺑـﻪ آـﺎر هـﺴﺘﻴﺪ و‬ ‫اﺣﺘﻴﺎج دارﻳﺪ ﺗﺎ در ﻧﺘﻴﺠﻪ ﺣﺴﺎب‪ ،‬ﻳﻚ ﻋﻼﻣﺖ ﺧﺎص ﻣﺜﻼ دﻻر )‪ ($‬ﻳﺎ رﻳﺎل ﻇﺎهﺮ ﺷﻮد‪.332345201‬را در ﻧﺘﻴﺠﻪ ي ﻳﻚ ﺣﺴﺎب ﺑﻪ دﺳﺖ ﻣﻲ ﺁورﻳﺪ‪.‬‬ ‫اﻳﻦ ﻧﺘﻴﺠﻪ ي ﺧﻮﺑﻲ اﺳﺖ اﻣﺎ اﮔﺮ ﻗﺮار ﺑﺎﺷﺪ اﻳﻦ ﻋﺪد در ﻳـﻚ ‪ TextBox‬ﻗـﺮار ﺑﮕﻴـﺮد آـﻪ ﺑـﺮاي ﺁن‬ ‫ﻣﺤﺪودﻳﺘﻲ از ﻟﺤﺎظ ﺗﻌﺪاد آﺎراآﺘﺮهﺎي ورودي ﻗﺎﺋﻞ ﺷﺪﻩ اﻳﺪ و اﻳﻦ ﻣﻘﺪار آﻤﺘﺮ از ﺗﻌـﺪاد ارﻗـﺎم اﻳـﻦ‬ ‫ﻋﺪد ﺑﺎﺷﺪ‪ ،‬ﺗﻤﺎﻣﻲ ارﻗﺎم در ‪ TextBox‬ﻗﺮار ﻧﻤﻲ ﮔﻴﺮﻧﺪ ﭘﺲ ﺑﺎﻳﺪ ﺑﺮاي اﻳـﻦ ﻋـﺪد ﻗﺎﻟـﺐ و ﻓﺮﻣﺘـﻲ‬ ‫ﺗﻌﻴﻴﻦ آﺮد‪ .‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ دادﻩ هﺎ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‬ ‫)‪:(Data Formatting‬‬ ‫‪ VB.14159265358979‬ﺧﻮاهﺪ ﺑﻮد‪.‬‬ ‫ﺁرﮔﻮﻣــﺎن ‪ ،expression‬ﻣــﻲ ﺗﻮاﻧــﺪ ﻳــﻚ ﻋــﺪد‪ ،‬رﺷــﺘﻪ ﻳــﺎ ﻣﻘــﺪاري از ﻧــﻮع ﺗــﺎرﻳﺦ ﺑﺎﺷــﺪ و ﺁرﮔﻮﻣــﺎن‬ ‫‪ ،Format‬ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي اﺳﺖ آﻪ ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ ﺗﺎﺑﻊ ﻣﺎ ﻣﻘﺪار ﺧﺮوﺟﻲ را ﺑﺎ ﭼﻪ ﻗﺎﻟﺐ ﻳﺎ‬ ‫ﻓﺮﻣﺘﻲ ﺑﺮﮔﺸﺖ و ﻧﻤﺎﻳﺶ دهﺪ‪.1416‬ﻧﻤﺎﻳﺶ ﺧﻮاهﺪ داد‪.33‬‬ ‫ﺁرﮔﻮﻣﺎن هﺎي ‪ firstdayofweek‬و ‪ ،firstweekofyear‬ﺗﻨﻬﺎ در ﻗﺎﻟﺐ دهﻲ ﺑـﻪ ﻣﻘـﺎدﻳﺮي از ﻧـﻮع‬ ‫ﺗﺎرﻳﺦ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‪.WriteLine(Format(amount.WriteLine(Format(Math.‬‬ ‫)]]] ‪Format(expression [.NET‬‬ ‫‪٢٩‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .##‬‬ ‫ﻧﺘﻴﺠﻪ ﺧﺮوﺟﻲ ﺑﻪ ﺻﻮرت زﻳﺮ ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ‪:‬‬ ‫‪$13.firstweekofyear‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ دﻟﻴﻞ اهﻤﻴﺖ و ﮔﺴﺘﺮﮔﻲ زﻳﺎدي آـﻪ دارد‪ ،‬ﺗـﺎﺑﻌﻲ اﺳـﺖ آـﻪ در اﻳـﻦ آﺘـﺎب‪ ،‬ﺑﻴـﺸﺘﺮﻳﻦ‬ ‫ﺗﻮﺿﻴﺤﺎت در ﻣﻮرد ﺁن دادﻩ ﺷﺪﻩ اﺳﺖ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،firstdayofweek‬ﻧﺎم اوﻟﻴﻦ روز هﻔﺘﻪ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ و ﻣﻲ ﺗﻮاﻧﺪ ﻳﻜـﻲ از ﻣﻘـﺎدﻳﺮ‬ ‫زﻳﺮ را ﺑﭙﺬﻳﺮد‪:‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.###.WriteLine(Math.

‬و… اﻣﺎ آﺎراآﺘﺮ ‪ ،d‬اﻋﺪاد ﻳﻚ ﺗﺎ ﻧﻪ را ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮل ﻧﺸﺎن‬ ‫ﻣﻲ دهﺪ ﻳﻌﻨﻲ ‪ 3 ،2،1‬و…‬ ‫‪ : ddd‬اﻳﻦ آﺎراآﺘﺮ‪ ،‬ﻧﺎم اﺧﺘﺼﺎري ﻳﻚ روز را ﻧﺸﺎن ﻣﻲ دهﺪ‪ .‬ﻣﺜﻼ‪(Sunday-Saturday) :‬‬ ‫‪ : w‬اﻳــﻦ آــﺎراآﺘﺮ‪ ،‬ﻋــﺪدي را آــﻪ ﻧﻤﺎﻳــﺎﻧﮕﺮ روز هﻔﺘــﻪ اﺳــﺖ ﻧــﺸﺎن ﻣــﻲ دهــﺪ‪ .‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ firstdayofweek‬در ﺗﺎﺑﻊ )(‪Format‬‬ ‫ﺗﻮﺿﻴﺤﺎت‬ ‫ﻣﻘﺪار‬ ‫ﻣﻄﺎﺑﻖ ﺑﺎ ﺗﻨﻈﻴﻤﺎت ﺳﻴﺴﺘﻢ‬ ‫‪ 0‬ﻳﺎ ‪System‬‬ ‫ﻳﻜﺸﻨﺒﻪ )ﻣﻘﺪار ﭘﻴﺶ ﻓﺮض(‬ ‫‪ 1‬ﻳﺎ ‪Sunday‬‬ ‫دوﺷﻨﺒﻪ‬ ‫‪ 2‬ﻳﺎ ‪Monday‬‬ ‫ﺳﻪ ﺷﻨﺒﻪ‬ ‫‪ 3‬ﻳﺎ ‪Tuesday‬‬ ‫ﭼﻬﺎرﺷﻨﺒﻪ‬ ‫‪ 4‬ﻳﺎ ‪Wednesday‬‬ ‫ﭘﻨﺞ ﺷﻨﺒﻪ‬ ‫‪ 5‬ﻳﺎ ‪Thursday‬‬ ‫ﺟﻤﻌﻪ‬ ‫‪ 6‬ﻳﺎ ‪Friday‬‬ ‫ﺷﻨﺒﻪ‬ ‫‪ 7‬ﻳﺎ ‪Saturday‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،firstweekofyear‬اوﻟﻴﻦ هﻔﺘﻪ از ﺳﺎل را ﻣـﺸﺨﺺ ﻣـﻲ آﻨـﺪ و ﻳﻜـﻲ از ﻣﻘـﺎدﻳﺮ زﻳـﺮ را‬ ‫ﻣﻲ ﭘﺬﻳﺮد‪:‬‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ firstweekofyear‬در ﺗﺎﺑﻊ )(‪Format‬‬ ‫ﺗﻮﺿﻴﺤﺎت‬ ‫ﻣﻘﺪار‬ ‫ﻣﻄﺎﺑﻖ ﺑﺎ ﺗﻨﻈﻴﻤﺎت ﺳﻴﺴﺘﻢ‪.‬‬ ‫ﻗﺎﻟﺐ هـﺎي ﻣﺨﺘﻠﻔـﻲ ﺑـﺮاي ﻧﻤـﺎﻳﺶ ﻣﻘـﺎدﻳﺮ ﻋـﺪدي‪ ،‬رﺷـﺘﻪ اي‪ ،‬ﺗـﺎرﻳﺦ و زﻣـﺎن وﺟـﻮد دارد آـﻪ در‬ ‫ﻟﻴﺴﺖ زﻳﺮ ﺗﻤﺎﻣﻲ ﺁﻧﻬﺎ را ﻣﻲ ﺑﻴﻨﻴﺪ‪:‬‬ ‫آﺎراآﺘﺮهﺎﻳﻲ آﻪ ﻣﻲ ﺗﻮان ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ ﺗﺎرﻳﺦ و زﻣﺎن ﺑﻪ آﺎر ﺑﺮد‪:‬‬ ‫‪ : /‬اﻳﻦ آﺎراآﺘﺮ‪ ،‬ﺟﻬﺖ ﺟﺪا آﺮدن ﺳﺎل‪ ،‬ﻣﺎﻩ و روز از ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ ﺑﻪ آـﺎر ﻣـﻲ رود‪ .‬‬ ‫‪ : MM‬اﻳﻦ آﺎراآﺘﺮ هﻤﺎﻧﻨﺪ آﺎراآﺘﺮ ‪ M‬رﻓﺘﺎر ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ اﻳـﻦ ﺗـﺎﺑﻊ ﻗﺒـﻞ از ارﻗـﺎم ‪ 0‬ﺗـﺎ‬ ‫‪ ،9‬ﺻﻔﺮ )‪ (0‬ﻣﻲ ﮔﺬارد اﻣﺎ آﺎراآﺘﺮ ‪ ،M‬اﻋﺪاد را ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮل ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪.‬ﻣــﺜﻼ ﻋــﺪد ‪1‬‬ ‫ﺑﺮاي ‪ Sunday‬و ‪ 7‬ﺑﺮاي ‪Saturday‬‬ ‫‪ : ww‬اﻳﻦ آﺎراآﺘﺮ‪ ،‬ﻋﺪدي را آﻪ ﻧﻤﺎﻳﺎﻧﮕﺮ هﻔﺘﻪ ﺳﺎل اﺳﺖ ﻧﻤﺎﻳﺶ ﻣﻲ دهـﺪ‪ .‬‬ ‫‪ : MMM‬اﻳﻦ آﺎراآﺘﺮ‪ ،‬ﻧﺎم اﺧﺘﺼﺎري ﻳﻚ ﻣﺎﻩ را ﻧﺸﺎن ﻣﻲ دهﺪ‪ .‬ﻣﺜﻼ‪(Sun-Sat) :‬‬ ‫‪ : dddd‬اﻳﻦ آﺎراآﺘﺮ‪ ،‬ﻧﺎم آﺎﻣﻞ روز را ﻧﺸﺎن ﻣﻲ دهﺪ‪ .‬‬ ‫‪ : :‬اﻳﻦ آﺎراآﺘﺮ‪ ،‬ﺟﻬﺖ ﺟﺪاآﺮدن ﺳﺎﻋﺖ‪ ،‬دﻗﻴﻘﻪ و ﺛﺎﻧﻴﻪ از ﻳﻚ ﻣﻘﺪار از ﻧﻮع زﻣﺎن ﺑـﻪ آـﺎر ﻣـﻲ رود‪.‬ﻣﺜﻼ‪(Jan-Dec) :‬‬ ‫‪ : MMMM‬اﻳﻦ آﺎراآﺘﺮ‪ ،‬ﻧﺎم آﺎﻣﻞ ﻣﺎﻩ را ﻧﺸﺎن ﻣﻲ دهﺪ‪ .‬‬ ‫اﻟﺒﺘﻪ در ﺑﻌﻀﻲ از ﻣﻜﺎن هﺎ ﻣﻤﻜﻦ اﺳﺖ از آﺎراآﺘﺮهﺎي دﻳﮕﺮي ﺟﻬﺖ اﻳﻦ آﺎر اﺳﺘﻔﺎدﻩ ﺷﻮد‪.‬اﮔـﺮ ﺑـﺎ آﺎراآﺘﺮهـﺎي ‪h‬‬ ‫ﻳﺎ ‪ hh‬ﺑﻴﺎﻳﺪ‪ ،‬ﺑﻪ ﺟﺎي ﻧﻤﺎﻳﺶ ﻋﺪد ﻣﺎﻩ‪ ،‬دﻗﻴﻘﻪ را ﻧﺸﺎن ﺧﻮاهﺪ داد‪.‬‬ ‫‪ : M‬اﻳﻦ آﺎراآﺘﺮ‪ ،‬ﻋﺪدي را آﻪ ﻧﻤﺎﻳﺎﻧﮕﺮ ﻣﺎﻩ ﺳﺎل اﺳﺖ ﻧﺸﺎن ﻣﻲ دهـﺪ‪ .‬‬ ‫ﺳﺎل ﺑﺎ هﻔﺘﻪ اي ﺁﻏﺎز ﻣـﻲ ﺷـﻮد آـﻪ آـﺎﻣﻼ در‬ ‫‪ 3‬ﻳﺎ ‪FirstFullWeek‬‬ ‫ﺳﺎل ﺟﺪﻳﺪ ﺑﺎﺷﺪ‪.‬‬ ‫‪ 0‬ﻳﺎ ‪System‬‬ ‫ﺳﺎل ﺑﺎ هﻔﺘﻪ اول ﻣﺎﻩ ژاﻧﻮﻳﻪ ﺁﻏﺎز ﻣﻲ ﺷﻮد‪.‬‬ ‫‪: dd‬اﻳﻦ آﺎراآﺘﺮ‪ ،‬هﻤﺎﻧﻨﺪ آﺎراآﺘﺮ ‪ d‬رﻓﺘﺎر ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻗﺒـﻞ از ارﻗـﺎم ﻳـﻚ ﺗـﺎ‬ ‫ﻧﻪ‪ ،‬ﺻﻔﺮ )‪ (0‬ﻣﻲ ﮔﺬارد‪ 03،02،01 .‬‬ ‫‪ 1‬ﻳﺎ ‪FirstJan1‬‬ ‫ﺳﺎل ﺑﺎ هﻔﺘﻪ اي ﺁﻏﺎز ﻣﻲ ﺷـﻮد آـﻪ ﺣـﺪاﻗﻞ ‪٤‬‬ ‫‪ 2‬ﻳﺎ ‪FirstFourDays‬‬ ‫روز ﺁن در ﺳﺎل ﺟﺪﻳﺪ ﺑﺎﺷﺪ‪.‬‬ ‫‪ : d‬اﻳﻦ آﺎراآﺘﺮ‪ ،‬روز ﻳﻚ ﻣﺎﻩ را ﺑﻪ وﺳﻴﻠﻪ ﻳﻚ ﻋﺪد ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ‪ .‬ﻣﺜﻼ‪(January-December) :‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬اﻳﻦ ﻋﺪد ﻣﻘﺪاري ﺑـﻴﻦ ‪ 1‬ﺗـﺎ‬ ‫‪ 31‬اﺳﺖ‪.NET‬‬ ‫‪٣٠‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬اﻳـﻦ ﻋـﺪد ﺑـﻴﻦ ‪1‬‬ ‫ﺗﺎ ‪ 54‬اﺳﺖ‪.‬اﻟﺒﺘـﻪ‬ ‫در ﺑﻌﻀﻲ ﻣﻜﺎن هﺎ ﻣﻤﻜﻦ اﺳﺖ از آﺎراآﺘﺮهﺎي دﻳﮕﺮي ﺟﻬﺖ اﻳﻦ آﺎر اﺳﺘﻔﺎدﻩ ﺷﻮد‪.

numDigitsAfterDecimal‬‬ ‫)] ‪[.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔﺮ ﺳﺎﻋﺖ ﻓﻌﻠﻲ ﺳﻴﺴﺘﻢ ‪ 3‬ﺑﺎﺷﺪ‪3 ،‬ﺻﺒﺢ را ﺑﺎ ﻋﺪد ‪ 3‬و ‪ 3‬ﺑﻌﺪ از ﻇﻬﺮ را ﺑﺎ ﻋـﺪد‬ ‫‪ 15‬ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪.‬ﺗﺎ ‪(12‬‬ ‫‪ : hh‬اﻳﻦ آﺎراآﺘﺮ هﻤﺎﻧﻨﺪ آﺎراآﺘﺮ ‪ h‬رﻓﺘﺎر ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ اﻳﻦ ﺗﺎﺑﻊ ﻗﺒﻞ از ارﻗﺎم ‪ 0‬ﺗﺎ ‪،12‬‬ ‫ﺻﻔﺮ )‪ (0‬ﻣﻲ ﮔﺬارد اﻣﺎ آﺎراآﺘﺮ ‪ ،h‬اﻋﺪاد را ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮل ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪.‫‪: q‬اﻳﻦ آﺎراآﺘﺮ‪ ،‬ﻳﻚ ﭼﻬﺎرم ﻳﻚ ﺳﺎل را ﺑﺎ اﻋﺪادي ﺑﻴﻦ ‪ 1‬ﺗﺎ ‪ 4‬ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪) .9‬ﺑﺎزﻩ ي اﻳﻦ آﺎراآﺘﺮ‪ ،‬ﻋﺪدي ﺑﻴﻦ ‪ 0‬ﺗﺎ ‪ 59‬اﺳﺖ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،includeLeadingDigit‬ﻳﻚ ﻣﻘﺪار ﺛﺎﺑـﺖ ‪ Tristate‬اﺳـﺖ‪) .groupDigits‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻳﻚ ﻣﻘﺪار ﻋﺪدي را ﺑﻪ ﺷﻜﻞ ﻳﻚ ﻣﻘﺪار ارزي )‪ (Currency‬ﻗﺎﻟﺐ ﺑﻨـﺪي ﺷـﺪﻩ هﻤـﺮاﻩ ﺑـﺎ‬ ‫ﻧﻤﺎدي آﻪ در ﺳﺮﺑﺮگ ‪ Regional Options‬از ﻗﺴﻤﺖ ‪Regional and Language Options‬‬ ‫از ‪ Control Panel‬ﻣﺸﺨﺺ ﺷﺪﻩ اﺳﺖ‪ ،‬ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.‬‬ ‫‪:m‬اﻳﻦ آﺎراآﺘﺮ‪ ،‬دﻗﻴﻘﻪ را را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪ ،‬ﻣﻨﺘﻬﺎ ﺑﺪون ﮔﺬاﺷﺘﻦ ﻋﺪد ﺻﻔﺮ ﻗﺒـﻞ از ارﻗـﺎم ‪ 0‬ﺗـﺎ‬ ‫‪ .‬‬ ‫‪ : AM/PM‬ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ هﻢ اآﻨﻮن ﻗﺒﻞ از ﻇﻬﺮ اﺳﺖ )‪ (AM‬ﻳﺎ ﺑﻌﺪ از ﻇﻬﺮ )‪(PM‬‬ ‫‪ :am/pm‬هﻤﺎن آﺎراآﺘﺮ ‪ AM/PM‬اﺳﺖ‪ ،‬ﻓﻘﻂ ﻗﺒﻞ ﻳﺎ ﺑﻌﺪ ﺑﻮدن ﻇﻬﺮ را ﺑﺎ ﺣﺮوف آﻮﭼـﻚ ﻧﻤـﺎﻳﺶ‬ ‫ﻣﻲ دهﺪ‪(am/pm) .‬‬ ‫‪ :s‬اﻳﻦ آﺎراآﺘﺮ‪ ،‬ﺛﺎﻧﻴﻪ را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪ ،‬ﻣﻨﺘﻬﺎ ﺑﺪون ﮔﺬاﺷﺘﻦ ﻋﺪد ﺻـﻔﺮ ﻗﺒـﻞ از ارﻗـﺎم ‪ 0‬ﺗـﺎ ‪.‬ﺛﺎﺑـﺖ ‪ ،Tristate‬ﻣﻘـﺪاري‬ ‫اﺳــﺖ آــﻪ ﻣــﻲ ﺗﻮاﻧــﺪ ‪ False ،True‬ﻳــﺎ ‪ UseDefault‬ﺑﺎﺷــﺪ( و ﻣــﺸﺨﺺ ﻣــﻲ آﻨــﺪ آــﻪ ﺁﻳــﺎ اﮔــﺮ‬ ‫ﻣﻘﺪاري اﻋﺸﺎري آﻤﺘﺮ از ‪ 1‬ﺑﻮد‪ ،‬در ﺳﻤﺖ ﭼﭗ اﻋﺸﺎر‪ ،‬ﻋﺪد ﺻﻔﺮ ﻗﺮار ﮔﻴﺮد ﻳﺎ ﺧﻴﺮ‪.9‬‬ ‫ﺑﺎزﻩ ي اﻳﻦ آﺎراآﺘﺮ ﺑﻴﻦ ‪ 0‬ﺗﺎ ‪ 59‬اﺳﺖ‪.‬ﺑﻪ ﻋﻨﻮان ﻣﺜـﺎل در وﻳﻨـﺪوز هـﺎي‬ ‫ﻓﺎرﺳﻲ ﺑﺎ آﻠﻤﺎت “ﺻﺒﺢ” و “ﻋﺼﺮ” ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪.7‬و ﻳﺎ ”‪ “.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻣﻘﺪاري ﻋﺪدي اﺳﺖ آﻪ ﻗﺼﺪ ﺑﺮﮔﺸﺖ ﺁن ﺑﺎ ﻓﺮﻣﺖ ‪ Currency‬را دارﻳﻢ‪.‬‬ ‫در اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﺗﻤﺎﻣﻲ ﺁرﮔﻮﻣﺎن هﺎ ﺑﻪ ﺟﺰ اوﻟﻴﻦ ﺁرﮔﻮﻣﺎن‪ ،‬اﺧﺘﻴﺎري هﺴﺘﻨﺪ‪.‬ﻳﺎ ‪(p‬‬ ‫‪ : AMPM‬اﻳﻦ آﺎراآﺘﺮ ﻧﻴﺰ ﻗﺒﻞ ﻳﺎ ﺑﻌﺪ ﺑﻮدن ﻇﻬﺮ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ اﻣـﺎ ﺑـﻪ ﺟـﺎي اﻳـﻦ آـﺎراآﺘﺮ‪،‬‬ ‫آﺎراآﺘﺮي آﻪ ﺑﻪ وﺳﻴﻠﻪ ﺳﻴﺴﺘﻢ ﺗﻌﻴﻴﻦ ﺷﺪﻩ ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ‪ .‬‬ ‫ﺑــﺮاي ﺗﻐﻴﻴــﺮ ﻧﺤــﻮﻩ ﻧﻤــﺎﻳﺶ‪ ،‬ﺑــﻪ ﺳــﺮﺑﺮگ ‪ Regional Options‬از ﻗــﺴﻤﺖ ‪Regional and‬‬ ‫‪ Language Options‬در ‪ Control Panel‬ﻣﺮاﺟﻌﻪ آﻨﻴﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،numDigitsAfterDecimal‬ﻣﻘﺪاري ﻋﺪدي اﺳﺖ آﻪ ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ ﭼﻨﺪ ﻋـﺪد در‬ ‫ﺳﻤﺖ راﺳـﺖ ﺑﻌـﺪ از اﻋـﺸﺎر ﺑﺎﻳـﺪ ﻗـﺮار ﺑﮕﻴﺮﻧـﺪ‪ .‬ﺗﺎ ‪(366‬‬ ‫‪ : yy‬اﻳﻦ آﺎراآﺘﺮ‪ ،‬ﻋﺪدي دو رﻗﻤﻲ را ﻧﺸﺎن ﻣﻲ دهﺪ آﻪ ﻧﻤﺎﻳﺎﻧﮕﺮ ﺳﺎل اﺳﺖ‪ 00) .‬‬ ‫ﺑــﻪ ﻋﻨــﻮان ﻣﺜــﺎل در وﻳﻨــﺪوزهﺎي ﻓﺎرﺳــﻲ‪ ،‬ﻧﻤــﺎد ﻣﻘــﺎدﻳﺮ ارزي ﺑــﺎ آﻠﻤــﻪ “رﻳــﺎل” و در وﻳﻨــﺪوزهﺎي‬ ‫اﻧﮕﻠﻴﺴﻲ ﺑﺎ آﺎراآﺘﺮ ”‪ ،“$‬ﻣﺸﺨﺺ ﻣﻲ ﺷﻮد‪.‬‬ ‫‪ :ss‬هﻤﺎﻧﻨﺪ آﺎراآﺘﺮ ‪ s‬رﻓﺘﺎر آﺮدﻩ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ ﻗﺒﻞ از اﻋﺪاد ‪ 0‬ﺗﺎ ‪ ،9‬ﺻﻔﺮ )‪ (0‬ﻣﻲ ﮔﺬارد‪.‬‬ ‫‪ : A/P‬ﻗﺒﻞ ﻳﺎ ﺑﻌﺪ ﺑﻮدن ﻇﻬﺮ را ﺑﺎ ﺣﺮوف اﺧﺘﺼﺎري ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ‪ A ) .‬‬ ‫] ‪FormatCurrency(expression [.7‬ﻧﻤﺎﻳﺶ دادﻩ ﺷﻮد‪.‬‬ ‫‪ : HH‬اﻳﻦ آﺎراآﺘﺮ‪ ،‬هﻤﺎﻧﻨﺪ آﺎراآﺘﺮ ‪ H‬رﻓﺘﺎر ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ ﻗﺒـﻞ از ارﻗـﺎم ‪ 0‬ﺗـﺎ ‪ ،9‬ﺻـﻔﺮ‬ ‫)‪ (0‬ﻣﻲ ﮔﺬارد‪ 00) .‬ﺗﺎ ‪ (09‬وﻟﻲ آﺎراآﺘﺮ ‪ ،H‬ارﻗﺎم ‪ 0‬ﺗﺎ ‪ 9‬را ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮل ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪.‬ﻣﻘـﺪار ﭘـﻴﺶ ﻓـﺮض‪ -1 ،‬اﺳـﺖ ﻳﻌﻨـﻲ ﺗﻨﻈﻴﻤـﺎت‬ ‫‪ Regional and Language Options‬را ﺑﻪ آﺎر ﻣﻲ ﺑﺮد‪.‬ﻳﺎ ‪(P‬‬ ‫‪ : a/p‬هﻤﺎن آﺎراآﺘﺮ ‪ A/P‬اﺳﺖ‪ ،‬ﻓﻘﻂ ﻗﺒﻞ ﻳﺎ ﺑﻌـﺪ ﺑـﻮدن ﻇﻬـﺮ را ﺑـﺎ ﺣـﺮوف آﻮﭼـﻚ ﻧﻤـﺎﻳﺶ ﻣـﻲ‬ ‫دهﺪ‪ a).‬‬ ‫آﺎراآﺘﺮهﺎﻳﻲ آﻪ ﻣﻲ ﺗﻮان ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ ﻣﻘﺎدﻳﺮ ﻋﺪدي ﺑﻪ آﺎر ﺑﺮد‪ ١٦ ،‬آـﺎراآﺘﺮ هـﺴﺘﻨﺪ آـﻪ‬ ‫ﻧﺤﻮﻩ ي آﺎر ﺑﺎ ﺁﻧﻬﺎ ﺑﺮ ﻋﻬﺪﻩ ي ﺧﻮاﻧﻨﺪﮔﺎن ﻋﺰﻳﺰ اﺳﺖ‪.‬ﺗـﺎ‬ ‫‪(9999‬‬ ‫‪ : h‬اﻳﻦ آﺎراآﺘﺮ‪ ،‬ﻋﺪدي را آﻪ ﻧﻤﺎﻳﺎﻧﮕﺮ ﺳﺎﻋﺖ اﺳﺖ ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪ 0) .‬ﻣﺘﻨﺎﻇﺮ ﻓﺼﻞ(‬ ‫‪ : y‬اﻳﻦ آﺎراآﺘﺮ‪ ،‬ﻋﺪدي را آﻪ ﻧﻤﺎﻳﺎﻧﮕﺮ روز ﺳﺎل اﺳﺖ ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪ 1) .NET‬‬ ‫‪٣١‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .includeLeadingDigit ][.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.useParensForNegativeNumbers ][.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻋﺪد هﻔﺖ دهﻢ آﻪ ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ ﺷﻜﻞ ”‪ “0.‬‬ ‫‪ : H‬اﻳﻦ آﺎراآﺘﺮ‪ ،‬ﺷﻜﻞ آﺎﻣﻠﺘﺮ آﺎراآﺘﺮ ‪ h‬اﺳﺖ و ﺳﺎﻋﺖ را ﺑﻪ ﺻﻮرت ‪ 0‬ﺗﺎ ‪ 24‬ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪.‬ﺗﺎ ‪(99‬‬ ‫‪ : yyyy‬اﻳﻦ آﺎراآﺘﺮ‪ ،‬ﻋﺪدي ‪ 4‬رﻗﻤﻲ را ﻧﻤﺎﻳﺶ ﻣﻲ دهـﺪ آـﻪ ﻧﻤﺎﻳـﺎﻧﮕﺮ ﺳـﺎل اﺳـﺖ‪ 0000) .‬‬ ‫ﺑﺮاي ﺗﻐﻴﻴﺮ ﻧﺤﻮﻩ ﻧﻤﺎﻳﺶ اﻳﻦ ﻣﻘﺎدﻳﺮ‪ ،‬ﺑﻪ ﻗﺴﻤﺖ ﮔﻔﺘﻪ ﺷﺪﻩ در ﺑﺎﻻ ﻣﺮاﺟﻌﻪ آﻨﻴﺪ‪.‬‬ ‫‪ :mm‬هﻤﺎﻧﻨﺪ آﺎراآﺘﺮ ‪ m‬رﻓﺘﺎر آﺮدﻩ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ ﻗﺒﻞ از اﻋﺪاد ‪ 0‬ﺗﺎ ‪ ،9‬ﺻﻔﺮ )‪ (0‬ﻣﻲ ﮔﺬارد‪.

‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ string‬آﻪ ﻣﻲ ﺗﻮاﻧﺪ از هﺮ ﻧﻮع ﻣﻘﺪاري ﺑﺎﺷﺪ‪ ،‬رﺷﺘﻪ اي را ﻣﺸﺨﺺ ﻣﻲ آﻨـﺪ آـﻪ ﺑﺎﻳـﺪ‬ ‫در ﺳﻤﺖ ﭼﭗ ﻳﺎ راﺳﺖ ﺁن‪ ،‬ﻓﻀﺎي ﺧﺎﻟﻲ اﺿﺎﻓﻪ ﺷﻮد‪.numDigitsAfterDecimal‬‬ ‫)] ‪[.len) .‬‬ ‫ﺗﻮﺟﻪ‪ :‬اﮔﺮ هﺮ دو ﻣﻘﺪار ﺗﺎرﻳﺦ و زﻣﺎن ﺑﻪ آﺎر روﻧﺪ‪ ،‬ﭘﺸﺖ ﺳﺮ هﻢ ﻧﻤﺎﻳﺶ دادﻩ ﺧﻮاهﻨﺪ ﺷﺪ‪.‬در ﺻﻮرت ‪ False‬ﺑﻮدن اﻳﻦ ﺁرﮔﻮﻣﺎن‪ ،‬اﻋﺪاد ﭘﺸﺖ ﺳﺮ هـﻢ و ﺑـﺪون‬ ‫آﺎراآﺘﺮ ﺟﺪاآﻨﻨﺪﻩ ﻇﺎهﺮ ﻣﻲ ﺷﻮﻧﺪ‪.‬ﻣﺜﻼ‪“ :‬ﺷﻨﺒﻪ‪ ١٤ .useParensForNegativeNumbers ][.‬‬ ‫‪ :LongDate‬اﻳﻦ ﻣﻘﺪار ﺛﺎﺑﺖ‪ ،‬ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗـﺎرﻳﺦ را ﺑـﻪ ﺻـﻮرت ﻃـﻮﻻﻧﻲ ﻧﻤـﺎﻳﺶ و ﺑﺮﮔـﺸﺖ‬ ‫ﻣﻲ دهﺪ‪ .456‬‬ ‫ﺑﻪ ﻃﺮﻳﻘﻲ آﻪ ﻣﺸﺎهﺪﻩ ﻣﻲ آﻨﻴﺪ ﺑﺎ آﺎراآﺘﺮ )‪ (.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ groupDigits‬هﻢ ﻳﻚ ﻣﻘﺪار ﺛﺎﺑﺖ ‪ Tristate‬اﺳﺖ و ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ ﺁﻳـﺎ اﻋـﺪاد ﺑـﻴﺶ‬ ‫از ‪ 5‬رﻗﻤﻲ ﺑﺎ آﺎراآﺘﺮي آﻪ در ﻗـﺴﻤﺖ ‪ Regional and Language Options‬ﻣـﺸﺨﺺ ﺷـﺪﻩ‬ ‫از ﻳﻜﺪﻳﮕﺮ ﺟﺪا ﺷﻮﻧﺪ ﻳﺎ ﺧﻴﺮ‪ .‬ﻣﺜﻼ‪”٢٠٠٤/٠٢/١٤“ :‬‬ ‫‪ :LongTime‬اﻳﻦ ﻣﻘﺪار ﺛﺎﺑﺖ‪ ،‬ﻳﻚ ﻣﻘﺪار از ﻧﻮع زﻣﺎن را ﺑـﻪ ﺻـﻮرت ﻃـﻮﻻﻧﻲ ﻧﻤـﺎﻳﺶ ﻣـﻲ دهـﺪ‪.‬‬ ‫)‪LSet(string.‬‬ ‫ﺗﻤﺎﻣﻲ ﺁرﮔﻮﻣﺎن هﺎي اﻳﻦ ﺗﺎﺑﻊ در ﺗﻮﺿﻴﺤﺎت ﺗﺎﺑﻊ )(‪ FormatCurrency‬ﺑﻴﺎن ﺷﺪﻧﺪ‪.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬‬ ‫ﺗﻤﺎﻣﻲ ﺁرﮔﻮﻣﺎن هﺎي اﻳﻦ ﺗﺎﺑﻊ در ﺗﻮﺿﻴﺤﺎت ﺗﺎﺑﻊ )(‪ FormatCurrency‬ﺑﻴﺎن ﺷﺪﻧﺪ‪.includeLeadingDigit ][.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،date‬ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ ﻳﺎ زﻣﺎن اﺳﺖ آﻪ ﺑﺎﻳﺪ ﻗﺎﻟﺐ ﺑﻨﺪي ﺷﻮد‪.groupDigits‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻳﻚ ﻣﻘﺪار ﻋﺪدي را ﺑﺎ ﻗﺎﻟﺐ ﺑﻨﺪي دﻳﮕﺮي ﺑﻪ ﺻﻮرت ﻋﺪدي ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.‬‬ ‫ﻣﺜﻼ‪ ٠٦:٥٨:٣٤“ :‬ﻋﺼﺮ”‬ ‫‪ :ShortTime‬اﻳﻦ ﻣﻘﺪار ﺛﺎﺑﺖ‪ ،‬ﻳﻚ ﻣﻘﺪار از ﻧﻮع زﻣﺎن را ﺑﻪ ﺻﻮرت آﻮﺗﺎﻩ ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪.‬‬ ‫)] ‪FormatDateTime(date [.‬‬ ‫ﻣﺜﻼ‪”١٩:٢٣“ :‬‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ‪ :‬ﺗﻤـﺎﻣﻲ ﻣﻘـﺎدﻳﺮ ﺛﺎﺑـﺖ ﺑـﺎﻻ‪ ،‬ﺑـﺮ اﺳـﺎس ﺗﻨﻈﻴﻤـﺎﺗﻲ آـﻪ در ﻗـﺴﻤﺖ ‪Regional and‬‬ ‫‪ Language Options‬از ‪ Control Panel‬ﺻﻮرت ﮔﺮﻓﺘﻪ اﺳﺖ ﻋﻤﻞ ﻣﻲ آﻨﻨﺪ‪.‫ﺁرﮔﻮﻣــﺎن ‪ ،useParensForNegativeNumbers‬ﻧﻴــﺰ ﻳــﻚ ﻣﻘــﺪار ﺛﺎﺑــﺖ ‪ Tristate‬اﺳــﺖ آــﻪ‬ ‫ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ ﺁﻳﺎ اﻋﺪاد ﻣﺜﺒﺖ را ﺑﺎ دو ﭘﺮاﻧﺘﺰ در دو ﻃﺮف ﺁﻧﻬﺎ ﺑﺮﮔﺸﺖ دهﺪ ﻳﺎ ﺧﻴﺮ‪. RSet(string.‬‬ ‫] ‪FormatPercent(expression [.numDigitsAfterDecimal‬‬ ‫)] ‪[.‬‬ ‫‪ :ShortDate‬اﻳﻦ ﻣﻘﺪار ﺛﺎﺑﺖ‪ ،‬ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ را ﺑﻪ ﺻﻮرت آﻮﺗﺎﻩ ﻧﻤﺎﻳﺶ و ﺑﺮﮔـﺸﺖ ﻣـﻲ‬ ‫دهﺪ‪ .‬‬ ‫اﻳﻦ ﺁرﮔﻮﻣﺎن ﻣﻲ ﺗﻮاﻧﺪ ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ زﻳﺮ را ﺑﭙﺬﻳﺮد‪:‬‬ ‫‪ :GeneralDate‬اﮔﺮ در ﺁرﮔﻮﻣﺎن ‪ ،date‬ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ ﺁﻣﺪﻩ ﺑﺎﺷﺪ‪ ،‬ﺗﺎرﻳﺦ ﺑﻪ ﺷﻜﻞ آﻮﺗﺎﻩ‬ ‫ﻣﺜﻼ ”‪“14/02/2004‬ﻧﻤﺎﻳﺶ دادﻩ ﺧﻮاهﺪ ﺷﺪ و اﮔﺮ ﻣﻘﺪار از ﻧﻮع زﻣـﺎن ﺑﺎﺷـﺪ‪ ،‬زﻣـﺎن ﺑـﻪ ﺷـﻜﻞ‬ ‫آﺎﻣﻞ ﻣﺜﻼ “ﻋﺼﺮ ‪ “06:47:55‬ﻧﻤﺎﻳﺶ دادﻩ ﻣﻲ ﺷﻮد‪.useParensForNegativeNumbers ][.‬ﺁﺑﺎن‪” ١٣٨٢ .‬‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،namedFormat‬ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ ﭼﻪ ﻧﻮع ﻗﺎﻟﺐ ﺑﻨﺪي ﺑﺎﻳﺪ ﺑﺮاي ﺗﺎرﻳﺦ ﻳـﺎ‬ ‫زﻣﺎن ﺑﻪ آﺎر رود‪.namedFormat‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ )‪ (Date‬ﻳﺎ زﻣﺎن )‪ (Time‬را ﻗﺎﻟﺐ ﺑﻨﺪي ﻣﻲ آﻨﺪ‪.groupDigits‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻳﻚ ﻋﺪد را ﺑﺮ ﺣﺴﺐ درﺻﺪ ﺑﺮﮔﺸﺖ ﻣـﻲ دهـﺪ ﻳﻌﻨـﻲ ﻋـﺪد را در ‪ ١٠٠‬ﺿـﺮب آـﺮدﻩ و ﺑـﺎ‬ ‫ﻧﻤﺎد درﺻﺪ )‪ (%‬و ﺑﺎ ﻗﺎﻟﺒﻲ آﻪ ﻣﺸﺨﺺ ﺷﺪﻩ اﺳﺖ ﺑﺮﮔﺸﺖ و ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪.‬از ﻳﻜﺪﻳﮕﺮ ﺟـﺪا ﺷـﺪﻩ و اﻋـﺪاد از ﺳـﻤﺖ راﺳـﺖ‪،‬‬ ‫ﺳﻪ ﺗﺎ ﺳﻪ ﺗﺎ ﺟﺪا ﻣﻲ ﺷﻮﻧﺪ‪ .includeLeadingDigit ][.len‬‬ ‫اﻳﻦ ﺗﻮاﺑﻊ‪ ،‬ﺑـﻪ ﺗﻌـﺪادي آـﻪ ﻣـﺸﺨﺺ ﻣـﻲ ﺷـﻮد‪ ،‬در ﺳـﻤﺖ ﭼـﭗ )‪ (Lset‬ﻳـﺎ راﺳـﺖ )‪ (Rset‬ﻳـﻚ‬ ‫ﻋﺒﺎرت‪ ،‬ﻓﻀﺎي ﺧﺎﻟﻲ ﻗﺮار ﻣﻲ دهﻨﺪ‪.NET‬‬ ‫‪٣٢‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل در ﺻﻮرت ‪ True‬ﺑﻮدن اﻳـﻦ ﺁرﮔﻮﻣـﺎن‪ ،‬ﻋـﺪد ‪234.‬‬ ‫] ‪FormatNumber(expression [.

WriteLine(“[“ & RSet(“Behrouz”.‬‬ ‫‪Dim a As Integer = 18‬‬ ‫))‪Console.‬‬ ‫ﻣﻜﺎﻧﻴﺰم آﺎر ﺗﺎﺑﻊ )(‪ Val‬ﺑﻪ اﻳﻦ ﺷﻜﻞ اﺳﺖ آﻪ از اﺑﺘﺪاي رﺷﺘﻪ ورودي ﺷﺮوع ﺑﻪ ﺧﻮاﻧـﺪن ﺁن ﻣـﻲ‬ ‫آﻨﺪ و زﻣﺎﻧﻲ آﻪ ﺑﻪ آﺎراآﺘﺮي ﻏﻴـﺮ ﻋـﺪدي رﺳـﻴﺪ ﺟـﺴﺘﺠﻮ ﻣﺘﻮﻗـﻒ و ﻧﺘﻴﺠـﻪ ﺑﺮﮔـﺸﺖ دادﻩ ﻣـﻲ‬ ‫ﺷﻮد‪.01‬‬ ‫[‬ ‫‪[Rad‬‬ ‫)‪Val(string) .NET‬‬ ‫‪٣٣‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .20‬‬ ‫))‪Console.WriteLine(RSet(34.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫” ‪Dim a As String =“18:6.10‬‬ ‫ﺧﺮوﺟﻲ ﭘﺲ از اﺟﺮا ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺧﻮاهﺪ ﺷﺪ‪:‬‬ ‫]‪Behrouz‬‬ ‫]‬ ‫‪34.WriteLine(Str(a‬‬ ‫ﻧﺘﻴﺠﻪ ﺧﺮوﺟﻲ‪ ،‬رﺷﺘﻪ ”‪ “18‬ﺧﻮاهﺪ ﺑﻮد‪.10‬‬ ‫))‪Console. Str(number‬‬ ‫ﺗﺎﺑﻊ )(‪ ،Val‬ﻳـﻚ ﻣﻘـﺪار رﺷـﺘﻪ اي را ﺑـﻪ ﻋﻨـﻮان ورودي درﻳﺎﻓـﺖ آـﺮدﻩ و ﺁن را ﺑـﻪ ﺻـﻮرت ﻣﻘـﺪاري‬ ‫ﻋﺪدي ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.‫ﺁرﮔﻮﻣﺎن ‪ len‬ﻧﻴﺰ ﻣﻘﺪاري ﻋﺪدي اﺳﺖ آﻪ ﺗﻌﺪاد ﻓﻀﺎي ﺧﺎﻟﻲ را آﻪ ﺑﺎﻳﺪ اﻳﺠﺎد ﺷﻮد ﻣﺸﺨﺺ ﻣﻲ‬ ‫آﻨﺪ‪.99‬‬ ‫‪4.99.WriteLine(RSet(4356.56‬‬ ‫‪4356.WriteLine(“[“ & LSet(“Rad”.01.‬‬ ‫ﻣﺜﺎل هﺎي زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫)”]“ & )‪Console.‬‬ ‫ﺗﺎﺑﻊ )(‪ Str‬دﻗﻴﻘﺎ ﻋﻜﺲ ﺗـﺎﺑﻊ )(‪ Val‬رﻓﺘـﺎر آـﺮدﻩ و ﻳـﻚ ﻣﻘـﺪار ﻋـﺪدي را درﻳﺎﻓـﺖ آـﺮدﻩ و ﺁن را ﺑـﻪ‬ ‫ﺻﻮرت ﻣﻘﺪاري ﻋﺪدي ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.10‬‬ ‫))‪Console.05‬‬ ‫))‪Console.20‬‬ ‫)”]“ & )‪Console.56.WriteLine(Val(a‬‬ ‫ﻧﺘﻴﺠﻪ ي ﺧﺮوﺟﻲ‪ ،‬ﻋﺪد ‪ 18‬ﺧﻮاهﺪ ﺑﻮد زﻳﺮا‬ ‫ﻣﺜﺎﻟﻲ ﺑﺮاي ﺗﺎﺑﻊ )(‪:Str‬‬ ‫آﺎراآﺘﺮ ”‪“:‬‬ ‫آﺎراآﺘﺮي ﻏﻴﺮ ﻋﺪدي اﺳﺖ‪.WriteLine(RSet(4.

57079‬ﺗﺎ ‪ 1.NET‬ﺑﺎﻳﺪ آﻼس ‪ Math‬را ﺑﻪ ﺑﺮﻧﺎﻣـﻪ ي ﺧـﻮد اﺿـﺎﻓﻪ ﻳـﺎ‬ ‫ﻗﺒﻞ از اﺳـﺘﻔﺎدﻩ از اﻳـﻦ ﻣﺘـﺪهﺎ‪ ،‬آﻠﻤـﻪ ‪ Math‬را ﻗﺒـﻞ از ﻧـﺎم ﻣﺘـﺪ ذآـﺮ آﻨﻴـﺪ ﻣﺜـﻞ‪،Math.01‬‬ ‫)‪Abs(-1.‬ﺣﺎﺻـﻞ ﻣﺘـﺪ )(‪،Cos‬‬ ‫ﻣﻘﺪاري ﺑﻴﻦ ‪ –1‬ﺗﺎ ‪ 1‬اﺳﺖ‪.‬‬ ‫ﻧﻜﺘﻪ‪ :‬ﺗﻘﺮﻳﺒﺎ ‪e=2.‫ﺗﻮاﺑﻊ رﻳﺎﺿﻲ‬ ‫)‪:(Math‬‬ ‫در ‪ VB.57079‬اﺳﺖ‪.3)=-0.‬‬ ‫ﻣﺜﺎل‪:‬‬ ‫‪Atan(2.‬‬ ‫)‪Atan(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ‪ ،‬ﺁرك ﺗﺎﻧﮋاﻧﺖ ﻳﻚ ﻣﻘﺪار را ﻣﺤﺎﺳﺒﻪ و ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.Cos‬‬ ‫)‪Abs(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ‪ ،‬ﻗﺪر ﻣﻄﻠﻖ ﻳﻚ ﻋﺒﺎرت ﻋﺪدي را ﻣﺤﺎﺳﺒﻪ ﻣﻲ آﻨﺪ‪.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ expression‬ﻣﻘﺪاري اﺳﺖ آﻪ ﺁرك ﺗﺎﻧﮋاﻧـﺖ ﺁن ﺑﺎﻳـﺪ ﻣﺤﺎﺳـﺒﻪ ﮔـﺮدد‪ .‬اﮔـﺮ ‪expression‬‬ ‫ﺑﺰرﮔﺘﺮ ﻳﺎ ﻣﺴﺎوي ﺻﻔﺮ ﺑﺎﺷﺪ‪ ،‬ﻧﺘﻴﺠﻪ ي ﻣﺘﺪ هﻤﺎن ﻋﺒﺎرت ‪ expression‬ﺧﻮاهﺪ ﺑﻮد وﮔﺮﻧﻪ ﻋﺒـﺎرت‬ ‫‪ expression‬در ﻋﺪد ‪ –1‬ﺿﺮب ﺷﺪﻩ و ﻧﺘﻴﺠﻪ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد‪.‬‬ ‫ﺑﺮاي اﺳﺘﻔﺎدﻩ از ﻣﺘﺪهﺎي رﻳﺎﺿﻲ در ‪ VB.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻋﺪدي اﺳﺖ آﻪ ﺑﺎﻳﺪ ﻗﺪر ﻣﻄﻠـﻖ ﺁن ﻣﺤﺎﺳـﺒﻪ ﮔـﺮدد‪ .01‬‬ ‫ﻧﺘﻴﺠﻪ هﺮ دو اﻳﻦ دﺳﺘﻮرات‪ ،‬ﻋﺪد ‪ 1.‬ﭘﺲ در اﻳﻦ ﺑﺨﺶ ﺁﻧﻬﺎ را ﺑﺎ ﻧﺎم ﻣﺘﺪ ﺻﺪا ﻣﻲ زﻧﻴﻢ‪.NET‬‬ ‫‪٣٤‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .3)=1.0‬ﺑﻪ ﻋﻨﻮان ﻣﺘﺪهﺎﻳﻲ در آـﻼس ‪ Math‬ﻗـﺮار دادﻩ ﺷـﺪﻩ‬ ‫اﻧﺪ‪ .‬ﻧﺘﻴﺠـﻪ اﻳـﻦ ﻣﺘـﺪ‪،‬‬ ‫ﻣﻘﺪاري ﺑﻴﻦ ‪ –1.31‬‬ ‫)‪Int(expression) .‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻋﺒﺎرﺗﻲ اﺳﺖ آﻪ ﺑﺎﻳﺪ آﺴﻴﻨﻮس ﺁن ﻣﺤﺎﺳﺒﻪ ﺷﻮد‪ .‬‬ ‫ﻣﺜﺎل‪:‬‬ ‫‪Exp(2)=7.16‬‬ ‫)‪Cos(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ‪ ،‬آﺴﻴﻨﻮس ﻳﻚ زاوﻳﻪ را ﺑﺮ ﺣﺴﺐ رادﻳﺎن ﻣﺤﺎﺳﺒﻪ ﻣﻲ آﻨﺪ‪.NET‬ﺗﻤﺎﻣﻲ ﺗﻮاﺑﻊ رﻳﺎﺿﻲ ‪ VB.‬‬ ‫ﻣﺜﺎل‪:‬‬ ‫‪Cos(0)=1‬‬ ‫‪Cos(2.7182‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻣﻘﺪاري ﻋﺪدي)ﺗﻮاﻧﻲ( اﺳﺖ آﻪ ﺑﺎﻳﺪ ﻋﺪد ﻧﭙـﺮ ﺁن ﻣﺤﺎﺳـﺒﻪ ﮔـﺮدد و ﻣـﻲ‬ ‫ﺗﻮاﻧﺪ ﻳﻚ ﻋﺪد ﺻﺤﻴﺢ‪ ،‬اﻋﺸﺎري‪ ،‬ﻣﺜﺒﺖ ﻳﺎ ﻣﻨﻔﻲ ﺑﺎﺷﺪ‪.01‬ﺧﻮاهﺪ ﺑﻮد‪.67‬‬ ‫)‪Exp(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ‪ ،‬ﺗﻮاﻧﻲ از ‪) e‬ﻋﺪد ﻧﭙﺮ( را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪. Fix(expression‬‬ ‫هﺮ دو اﻳﻦ ﻣﺘﺪهﺎ‪ ،‬ﻣﻘﺪاري ﻋﺪدي را درﻳﺎﻓﺖ آﺮدﻩ و ﻋﺪدي از ﻧﻮع ‪) Integer‬ﺻـﺤﻴﺢ( را ﺑﺮﮔـﺸﺖ‬ ‫ﻣﻲ دهﻨﺪ‪.6.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫)‪Abs(1.Abs) :‬‬ ‫‪(Math.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ expression‬ﻋﺒﺎرﺗﻲ ﻋﺪدي اﺳﺖ آﻪ ﺑﻪ ﻋﻨﻮان ورودي اﻳﻦ ﻣﺘﺪهﺎ دادﻩ ﻣﻲ ﺷﻮد‪.

51)=4‬‬ ‫‪Round(3.3)=-3‬‬ ‫‪Fix(-2.5‬‬ ‫‪Round(3.5)=15‬‬ ‫‪Int(-2.5)))=250‬‬ ‫‪Fix(15.51.3)=-2‬‬ ‫ﭘﻴﺸﻨﻬﺎد ﻣﻲ آﻨﻢ اﮔﺮ ﻣﻲ ﺧﻮاهﻴﺪ آﻪ از دﺳﺖ ﻗﺴﻤﺖ اﻋﺸﺎري ﻳﻚ ﻋﺪد ﺧـﻼص ﺷـﻮﻳﺪ و ﺁن را‬ ‫اﺻﻄﻼﺣﺎ ﮔﺮد آﻨﻴﺪ‪ ،‬ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ آﻨﻴﺪ‪:‬‬ ‫)‪Int(value +0.‬‬ ‫)] ‪Round(expression [.‬‬ ‫اﻳﻦ دﺳﺘﻮر‪ ،‬ﻓﺮﻣﺎن ﺑﺴﻴﺎر آﺎرﺁﻣﺪي ﺑﺮاي ﮔﺮدآﺮدن هﺮ ﻧـﻮع ﻣﻘـﺪاري ﻋـﺪدي اﺳـﺖ ﺑـﺎ اﻳـﻦ وﺟـﻮد‪،‬‬ ‫ﻣﺘﺪ )(‪ Round‬آﻪ در ﻗﺴﻤﺖ ﺑﻌﺪ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻩ اﺳﺖ ﺑﻪ ﺷﻴﻮﻩ اي ﺁﺳﺎﻧﺘﺮ‪ ،‬ﺑﻬﺘـﺮ و آﺎرﺁﻣـﺪﺗﺮ‬ ‫اﻳﻦ آﺎر را اﻧﺠﺎم ﻣﻲ دهﺪ‪.5‬‬ ‫)‪Log(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ‪ ،‬ﻟﮕـﺎرﻳﺘﻢ ﻃﺒﻴﻌـﻲ )ﻳـﺎ ﻟﮕـﺎرﻳﺘﻢ ﭘﺎﻳـﻪ ‪ e‬آـﻪ ﺗﻘﺮﻳﺒـﺎ ‪ e=2.1)=3.‬‬ ‫)‪Log10 =Log(number)/Log(10‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬ ‫‪٣٥‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .5‬‬ ‫‪ ،Value‬ﻣﻘﺪاري ﻋﺪدي اﺳﺖ آﻪ ﻗﺼﺪ ﮔﺮد آﺮدن ﺁن را دارﻳﺪ‪.‬‬ ‫ﺑﺮاي ﻣﺤﺎﺳﺒﻪ ﻟﮕﺎرﻳﺘﻢ هﺎ در ﭘﺎﻳﻪ هـﺎي دﻳﮕـﺮ‪ ،‬ﻋـﺪد ﻟﮕـﺎرﻳﺘﻢ ﻃﺒﻴﻌـﻲ را ﺑـﺮ ﻟﮕـﺎرﻳﺘﻢ ﭘﺎﻳـﻪ ﺗﻘـﺴﻴﻢ‬ ‫آﻨﻴﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻣﻘﺪاري اﺳﺖ آﻪ ﺑﺎﻳﺪ ﮔﺮد ﺷﻮد‪.‬‬ ‫ﻣﺜﺎل هﺎي زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫‪Int(12)=12‬‬ ‫‪Fix(6)=6‬‬ ‫‪Int(14.‬‬ ‫اﮔﺮ ﻣﻘـﺪار ورودي‪ ،‬اﻋـﺸﺎري و ﻣﺜﺒـﺖ ﺑﺎﺷـﺪ‪ ،‬ﻗـﺴﻤﺖ اﻋـﺸﺎري ﺣـﺬف ﺷـﺪﻩ و ﻗـﺴﻤﺖ ﺻـﺤﻴﺢ‬ ‫ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪ ،‬دﺳﺘﻮر زﻳﺮ ﻟﮕﺎرﻳﺘﻢ ﻳﻚ ﻋﺪد در ﭘﺎﻳﻪ ي ‪ 10‬را ﻣﺤﺎﺳﺒﻪ ﻣﻲ آﻨﺪ‪.1)=3.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻣﻘﺪاري ﻋﺪدي اﺳﺖ آﻪ ﻟﮕﺎرﻳﺘﻢ ﻃﺒﻴﻌﻲ ﺁن ﺑﺎﻳﺪ ﻣﺤﺎﺳـﺒﻪ ﺷـﻮد و ﺣﺘﻤـﺎ‬ ‫ﺑﺎﻳﺪ ﻣﻘﺪاري ﻣﺜﺒﺖ ﺑﺎﺷﺪ‪.‬اﮔــﺮ از ذآــﺮ اﻳــﻦ ﺁرﮔﻮﻣــﺎن ﺧــﻮدداري ﺷــﻮد‪ ،‬ﻳــﻚ ﻣﻘــﺪار از ﻧــﻮع ﺻــﺤﻴﺢ‬ ‫)‪ (Integer‬ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد‪.‬‬ ‫ﻟﮕﺎرﻳﺘﻢ ﻃﺒﻴﻌﻲ‪ ،‬ﻟﮕﺎرﻳﺘﻢ ﭘﺎﻳﻪ ﻋﺪد ‪) e‬ﻧﭙﺮ( اﺳﺖ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ numdecimalplaces‬ﻣﺸﺨﺺ ﻣﻲ آﻨـﺪ آـﻪ اﻳـﻦ ﻣﻘـﺪار ﺗـﺎ ﭼﻨـﺪ رﻗـﻢ ﺑﻌـﺪ از‬ ‫اﻋــﺸﺎر ﺑﺎﻳــﺪ ﮔــﺮد ﺷــﻮد‪ .‫اﮔﺮ ﻣﻘﺪار ورودي‪ ،‬ﺻﺤﻴﺢ و ﻣﺜﺒﺖ ﻳﺎ ﻣﻨﻔﻲ ﺑﺎﺷﺪ‪ ،‬هﻤﺎن ﻣﻘﺪار ‪ expression‬ﺑﺮﮔـﺸﺖ دادﻩ ﻣـﻲ‬ ‫ﺷﻮد‪.‬‬ ‫ﻣﺜﺎل هﺎي زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫‪Round(3.49.23)=14‬‬ ‫‪Int(500/Int(2.7182‬اﺳـﺖ( ﻣﻘـﺪاري را ﺑﺮﻣـﻲ‬ ‫ﮔﺮداﻧﺪ‪.‬‬ ‫ﻣﻘﺪار دﻗﻴﻖ ﻋﺪد ﻧﭙﺮ را ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺎ دﺳﺘﻮر )‪ Exp(1‬ﺑﻪ دﺳﺖ ﺑﻴﺎورﻳﺪ‪.49)=3‬‬ ‫‪Round(3.‬‬ ‫در دوﻣﻴﻦ ﺣﺎﻟﺖ اﮔﺮ از ﻣﺘﺪ )(‪ Fix‬اﺳﺘﻔﺎدﻩ ﺷـﻮد‪ ،‬اوﻟـﻴﻦ ﻋـﺪد ﺻـﺤﻴﺢ ﻣﻨﻔـﻲ ﺑﺰرﮔﺘـﺮ ﻳـﺎ ﻣـﺴﺎوي‬ ‫ﻋﺒﺎرت ورودي ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد‪.‬‬ ‫ﻋﺒﺎرت ))‪ Log(Exp(N‬و ))‪ Exp(Log(N‬هﺮ دو ﻋﺪد ‪ N‬را ﺑﺮﻣﻲ ﮔﺮداﻧﻨﺪ‪.‬‬ ‫اﮔﺮ ﻣﻘﺪار ورودي‪ ،‬اﻋﺸﺎري و ﻣﻨﻔﻲ ﺑﺎﺷﺪ دو ﺣﺎﻟﺖ دارد‪:‬‬ ‫در ﺣﺎﻟﺖ اول اﮔﺮ از ﻣﺘـﺪ )(‪ Int‬اﺳـﺘﻔﺎدﻩ ﺷـﻮد‪ ،‬اوﻟـﻴﻦ ﻋـﺪد ﺻـﺤﻴﺢ ﻣﻨﻔـﻲ آـﻮﭼﻜﺘﺮ ﻳـﺎ ﻣـﺴﺎوي‬ ‫ﻋﺒﺎرت ورودي ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد‪.numdecimalplaces‬‬ ‫اﻳﻦ ﻣﺘﺪ‪ ،‬ﻳﻚ ﻋﺪد اﻋﺸﺎري را ﮔﺮد ﻣﻲ آﻨﺪ‪.

‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻋﺒﺎرت )‪ ،Hex(47‬ﻣﻘﺪار ”‪ “2F‬و ﻋﺒـﺎرت )‪ Oct(47‬ﻣﻘـﺪار ”‪ “57‬را ﺑﺮﮔـﺸﺖ ﻣـﻲ‬ ‫دهﻨﺪ‪.12‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.3) = -1.‬‬ ‫دﺳﺘﻮر زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫))‪Console.‫)‪Hex(expression) .‬‬ ‫)‪Sin(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ‪ ،‬ﺳﻴﻨﻮس زاوﻳﻪ اي را ﺑﺮ ﺣﺴﺐ رادﻳﺎن ﻣﺤﺎﺳﺒﻪ و ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.3) = 0.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻋﺒﺎرﺗﻲ اﺳﺖ آﻪ ﺳﻴﻨﻮس ﺁن ﺑﺎﻳﺪ ﻣﺤﺎﺳﺒﻪ ﺷﻮد‪.‬‬ ‫ﻓﺮض آﻨﻴﺪ ﻣﻘﺎدﻳﺮ زﻳﺮ ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﺑﺎﺷﻨﺪ‪:‬‬ ‫‪Dvalue =199 : Ovalue =&O77‬‬ ‫ﺣﺎل دﺳﺘﻮر )‪ ،Oct(Dvalue‬ﻣﻘﺪار رﺷﺘﻪ اي ”‪ “307‬و دﺳﺘﻮر )‪ Hex(Dvalue‬ﻣﻘﺪار رﺷﺘﻪ اي‬ ‫”‪ “3F‬را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.value2‬‬ ‫اﻳﻦ ﻣﺘﺪ‪ ،‬دو ﻋﺪد را ﺑﻪ ﻋﻨﻮان ورودي درﻳﺎﻓﺖ آﺮدﻩ و ﻋﺪد اول را ﺑﻪ ﺗﻮان ﻋﺪد دوم ﻣﻲ رﺳﺎﻧﺪ‪.NET‬‬ ‫‪٣٦‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﻧﺘﻴﺠﻪ ﻣﺘﺪ )(‪ ،Sin‬ﻣﻘﺪاري ﺑﻴﻦ ‪ 1‬ﺗﺎ ‪ –1‬اﺳﺖ‪.‬ﺑﻪ ﺗﻮان ‪ ٣‬ﺑﺮاﺑﺮ ﺑﺎ ‪ ٨‬اﺳﺖ‪.‬‬ ‫ﻣﻲ ﺗﻮاﻧﻴﺪ از آﺎراآﺘﺮهﺎي ﻣﻌﺎدل اﻳﻦ ﻣﺘﺪهﺎ ﻧﻴﺰ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪ . Oct(expression‬‬ ‫اﻳــﻦ ﻣﺘــﺪهﺎ ﻋــﺪدي را ﺑــﻪ ﻋﻨــﻮان ورودي درﻳﺎﻓــﺖ آــﺮدﻩ و ﺁن را ﺑــﻪ ﻣﺒﻨــﺎي ‪ (Oct) ٨‬ﻳــﺎ ﻣﺒﻨــﺎي ‪١٦‬‬ ‫)‪ (Hex‬ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﻨﺪ و ﺑﻪ ﺻﻮرت ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي )‪ (String‬ﺑﺮﮔﺸﺖ ﻣﻲ دهﻨﺪ‪.‬‬ ‫)‪Tan(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ‪ ،‬ﺗﺎﻧﮋاﻧﺖ زاوﻳﻪ اي را ﺑﺮ ﺣﺴﺐ رادﻳﺎن ﻣﺤﺎﺳﺒﻪ ﻣﻲ آﻨﺪ‪.75‬‬ ‫)‪Sqrt(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ‪ ،‬ﻣﺮﺑﻊ )ﻋﺪد ﺑﻪ ﺗﻮان ‪ (٣‬ﻳﻚ ﻣﻘﺪار ﻋﺪدي را ﻣﺤﺎﺳﺒﻪ و ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.‬‬ ‫ﺑﺮاي ﺗﻌﻴﻴﻦ آﺮدن اﻋﺪاد در ﻣﺒﻨﺎي ‪ ،١٦‬اﺑﺘﺪاي ﺁﻧﻬﺎ آﺎراآﺘﺮ ”‪ “&H‬را ﻗﺮار دهﻴﺪ‪.3‬‬ ‫در ﺧﺮوﺟﻲ‪ ،‬ﻋﺪد ‪ ٨‬ﻧﻤﺎﻳﺶ دادﻩ ﺧﻮاهﺪ ﺷﻮد‪ ٢ .‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻋﺪدي اﺳﺖ آﻪ ﺑﺎﻳﺪ ﻣﺮﺑﻊ ﺁن ﻣﺤﺎﺳﺒﻪ ﺷﻮد‪.‬ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫)‪MsgBox (“The number 3F in decimal is “ & &H3F‬‬ ‫ﻣﻘﺪاري آﻪ ﻧﺸﺎن دادﻩ ﻣﻲ ﺷﻮد‪ ،‬ﻋﺪد ‪ 63‬ﺧﻮاهﺪ ﺑﻮد‪.‬‬ ‫آﺎراآﺘﺮ و ﻧﻤﺎد ﻣﻌﺎدل ﺑﺮاي اﻋﺪاد در ﻣﺒﻨﺎي ‪ ،٨‬آﺎراآﺘﺮ ”‪ “&0‬ﻣﻲ ﺑﺎﺷﺪ‪.‬‬ ‫ﻣﺜﺎل‪:‬‬ ‫‪Tan(2.‬‬ ‫ﻣﺜﺎل‪:‬‬ ‫‪Sin(2.Pow(2.WriteLine(Math.‬‬ ‫)‪Pow(value1.

NET‬وﺟـﻮد دارد آـﻪ ﻣﻤﻜـﻦ اﺳـﺖ در‬ ‫ﺑﺮﺧﻮرد اول ﺑﺎ اﻳﻦ ﺗﻮاﺑﻊ‪ ،‬از ﺗﻨﻮع ﺁﻧﻬﺎ ﺗﻌﺠﺐ آﻨﻴﺪ!‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ‪ :‬در ‪ ،VB‬ﻣﻘﺎدﻳﺮي آﻪ از ﻧﻮع ﺗﺎرﻳﺦ هﺴﺘﻨﺪ ﺑﺎﻳﺪ ﺣﺘﻤﺎ ﺑﻴﻦ دو ﻋﻼﻣﺖ )‪ (#‬ﻗﺮار ﮔﻴﺮﻧﺪ‪.‬‬ ‫)(‪Now‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﺗﺎرﻳﺦ و زﻣﺎن ﺟﺎري ﺳﻴﺴﺘﻢ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬‬ ‫ﻣﺜﻼ‪ 1 ،‬ﺑﺮاي ‪ 2 ،Sunday‬ﺑﺮاي ‪ Monday‬و ﺑﻪ هﻤﻴﻦ ﺗﺮﺗﻴﺐ‪.firstdayofweek‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ هﻤﺎﻧﻨﺪ ﺗﺎﺑﻊ )(‪ Weekday‬ﻋﻤﻞ ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ اﻳـﻦ ﺗـﺎﺑﻊ‪ ،‬ﻧـﺎم روز ﻣﻌـﺎدل ﻳـﻚ‬ ‫ﻋﺪد آﻪ ﺑﻴﻦ ‪ 1‬ﺗﺎ ‪ 7‬اﺳﺖ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ date‬ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ اﺳﺖ‪.‬ﺑـﻪ ﻃـﻮر ﭘـﻴﺶ‬ ‫ﻓﺮض اﻳﻦ ﻣﻘﺪار ‪ False‬اﺳﺖ ﻳﻌﻨﻲ ﻧﺎم ﺑﻪ ﺻﻮرت آﺎﻣﻞ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد‪.TimeOfDay.firstdayofweek‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻋﺪدي ﺑﻴﻦ ‪ 1‬ﺗﺎ ‪ 7‬را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ آﻪ ﻣﺸﺨﺺ آﻨﻨﺪﻩ روز هﻔﺘﻪ اﺳﺖ‪.abbreviate [.‬‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ‪ :‬ﺑﺮاي اﺳﺘﺨﺮاج ﺗﻨﻬﺎ ﺗﺎرﻳﺦ ﻳﺎ زﻣﺎن ﺑﺮﮔﺸﺖ دادﻩ ﺷـﺪﻩ از اﻳـﻦ ﺗـﺎﺑﻊ‪ ،‬از ﺧـﻮاص ‪ Date‬و‬ ‫‪ TimeOfDay‬اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،abbreviate‬ﻳﻚ ﻣﻘﺪار ﻣﻨﻄﻘﻲ )‪ (Boolean‬اﺳﺖ آﻪ ﻣﺸﺨﺺ ﻣـﻲ آﻨـﺪ ﺁﻳـﺎ‬ ‫ﻧﺎم روزي آﻪ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد ﺑﻪ ﺻﻮرت آﻮﺗـﺎﻩ و اﺧﺘـﺼﺎري ﺑﺎﺷـﺪ ﻳـﺎ ﺧﻴـﺮ‪ .WriteLine(Now.ToString‬‬ ‫)‪Day(date‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ را ﺑﻪ ﻋﻨﻮان ورودي ﻣﻲ ﭘﺬﻳﺮد و روز ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬‬ ‫ﻣﺜﺎل‪:‬‬ ‫))(‪MsgBox(Now‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪ ،‬ﺧﺮوﺟﻲ دﺳﺘﻮر ﻓﻮق ﻣﻲ ﺗﻮاﻧﺪ ”‪ “02/10/2004 09:23:10 PM‬ﺑﺎﺷﺪ‪.‬‬ ‫ﻣﻄﺎﺑﻖ ﺑﺎ ﺗﻨﻈﻴﻤﺎت ﺳﻴﺴﺘﻢ >>> ‪ 0‬ﻳﺎ ‪System‬‬ ‫ﻳﻜﺸﻨﺒﻪ )ﻣﻘﺪار ﭘﻴﺶ ﻓﺮض( >>> ‪ 1‬ﻳﺎ ‪Sunday‬‬ ‫دوﺷﻨﺒﻪ >>> ‪ 2‬ﻳﺎ ‪Monday‬‬ ‫ﺳﻪ ﺷﻨﺒﻪ >>> ‪ 3‬ﻳﺎ ‪Tuesday‬‬ ‫ﭼﻬﺎرﺷﻨﺒﻪ >>> ‪ 4‬ﻳﺎ ‪Wednesday‬‬ ‫ﭘﻨﺞ ﺷﻨﺒﻪ >>> ‪ 5‬ﻳﺎ ‪Thursday‬‬ ‫ﺟﻤﻌﻪ >>> ‪ 6‬ﻳﺎ ‪Friday‬‬ ‫ﺷﻨﺒﻪ >>> ‪ 7‬ﻳﺎ ‪Saturday‬‬ ‫)]] ‪WeekdayName(weekday [.ToString‬‬ ‫)‪Console.‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ ﺗﺎرﻳﺦ و زﻣﺎن ﺳﺮ و آﺎر دارﻧﺪ‬ ‫)‪:(Date and Time‬‬ ‫ﺗﻮاﺑﻊ آﺎرﺑﺮدي و آﺎرﺁﻣﺪي ﺟﻬﺖ آﺎر ﺑﺎ ﺗﺎرﻳﺦ و زﻣﺎن در ‪ VB.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ weekday‬ﻳﻚ ﻣﻘﺪار ﻋﺪدي ﺻﺤﻴﺢ اﺳﺖ و ﻋﺪدي ﺑﻴﻦ ‪ 1‬ﺗﺎ ‪ 7‬را ﻣﻲ ﭘﺬﻳﺮد‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔﺮ ﻣﻘﺪار ورودي‪ ،‬ﺗﺎرﻳﺦ ‪ 12/15/2004‬ﺑﺎﺷﺪ‪ ،‬ﻣﻘﺪار ﺧﺮوﺟﻲ ﻋـﺪد ‪ 15‬ﻳﻌﻨـﻲ روز‬ ‫ﺗﺎرﻳﺦ ﺧﻮاهﺪ ﺑﻮد‪.‬‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﺗﺎرﻳﺦ و زﻣﺎن ﺑﺎ آﺎراآﺘﺮ ﺧﺎﻟﻲ )‪ (Blank‬از هﻢ ﺟﺪا ﺷﺪﻩ اﻧﺪ‪.‬‬ ‫)‪Console.NET‬‬ ‫‪٣٧‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﻣﺜﺎل زﻳﺮ روز ﺟﺎري ﺳﻴﺴﺘﻢ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.WriteLine(Now.Date.‬‬ ‫))(‪Day(Now‬‬ ‫)] ‪Weekday(date [.‬‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،firstdayofweek‬اوﻟﻴﻦ روز هﻔﺘﻪ را ﻣﺸﺨﺺ ﻣـﻲ آﻨـﺪ و ﻣـﻲ ﺗﻮاﻧـﺪ ﻳﻜـﻲ از‬ ‫ﻣﻘﺎدﻳﺮ زﻳﺮ را ﺑﭙﺬﻳﺮد‪:‬‬ ‫ﻣﻘﺪار اﻳﻦ ﺁرﮔﻮﻣﺎن ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ‪ Sunday‬ﻳﻌﻨﻲ ﻳﻜﺸﻨﺒﻪ اﺳﺖ‪.

‬‬ ‫ﻣﻘﺪاري آﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﻣﻲ ﮔﺮداﻧﺪ ﺑﻴﻦ ‪ 0‬ﺗﺎ ‪ 59‬اﺳﺖ‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل دﺳﺘﻮر زﻳﺮ ﺛﺎﻧﻴﻪ ﺟﺎري ﺳﻴﺴﺘﻢ را ﻧﺸﺎن ﻣﻲ دهﺪ‪:‬‬ ‫)))(‪Console.‬‬ ‫ﻣﻘﺪاري آﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪ ،‬ﻋﺪدي ﺑﻴﻦ ‪ 0‬ﺗﺎ ‪ 9999‬ﻣﻲ ﺑﺎﺷﺪ‪.WriteLine(Hour(Now‬‬ ‫)‪Minute(time‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ از ﻣﻘﺪار زﻣﺎن‪ ،‬دﻗﻴﻘﻪ ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،month‬ﻣﻘﺪاري ﻋﺪدي و ﺑـﻴﻦ ‪ 1‬ﺗـﺎ ‪ 12‬اﺳـﺖ آـﻪ ﺑﺎﻳـﺪ ﻣـﺎﻩ ﻣﺘﻨـﺎﻇﺮ ﺁن ﺑﺮﮔـﺸﺖ دادﻩ‬ ‫ﺷﻮد‪.WriteLine(Second(Now‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل دﺳﺘﻮر زﻳﺮ دﻗﻴﻘﻪ ﺟﺎري ﺳﻴﺴﺘﻢ را ﻧﺸﺎن ﻣﻲ دهﺪ‪:‬‬ ‫)))(‪Console.‬‬ ‫ﻣﻘﺪار اﻳﻦ ﺁرﮔﻮﻣﺎن ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ‪ Sunday‬ﻳﻌﻨﻲ ﻳﻜﺸﻨﺒﻪ اﺳﺖ‪.abbreviate‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻧﻴﺰ هﻤﺎﻧﻨﺪ ﺗﺎﺑﻊ )(‪ Month‬ﻋﻤﻞ ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ ﺑﻪ ﺟﺎي ﻋﺪد ﻣـﺎﻩ‪ ،‬ﻧـﺎم ﻣـﺎﻩ را‬ ‫ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،Time‬ﻣﻘﺪاري از ﻧﻮع زﻣﺎن )‪ (Time‬اﺳﺖ آﻪ ﺳﺎﻋﺖ ﺁن ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺑﺮاي ﺑﻪ دﺳـﺖ ﺁوردن ﻋـﺪد ﻣﺘﻨـﺎﻇﺮ ﻣـﺎﻩ ﺟـﺎري ﺳﻴـﺴﺘﻢ از دﺳـﺘﻮر زﻳـﺮ اﺳـﺘﻔﺎدﻩ‬ ‫آﻨﻴﺪ‪:‬‬ ‫))(‪Month(Date‬‬ ‫)] ‪MonthName(month [.‬ﺑـﻪ ﻃـﻮر ﭘـﻴﺶ‬ ‫ﻓﺮض اﻳﻦ ﻣﻘﺪار ‪ False‬اﺳﺖ ﻳﻌﻨﻲ ﻧﺎم ﻣﺎﻩ ﺑﻪ ﺻﻮرت آﺎﻣﻞ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد‪.‬‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،abbreviate‬ﻳﻚ ﻣﻘﺪار ﻣﻨﻄﻘﻲ )‪ (Boolean‬اﺳﺖ آﻪ ﻣﺸﺨﺺ ﻣـﻲ آﻨـﺪ ﺁﻳـﺎ‬ ‫ﻧﺎم ﻣﺎهﻲ آﻪ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد ﺑﻪ ﺻﻮرت آﻮﺗﺎﻩ و اﺧﺘـﺼﺎري ﺑﺎﺷـﺪ ﻳـﺎ ﺧﻴـﺮ‪ .NET‬‬ ‫‪٣٨‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﻣﻘﺪاري آﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﻣﻲ ﮔﺮداﻧﺪ ﺑﻴﻦ ‪ 0‬ﺗﺎ ‪ 59‬اﺳﺖ‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺑﺮاي ﺑﻪ دﺳﺖ ﺁوردن ﻋﺪد ﻣﺘﻨﺎﻇﺮ ﺳـﺎل ﺟـﺎري ﺳﻴـﺴﺘﻢ از دﺳـﺘﻮر زﻳـﺮ اﺳـﺘﻔﺎدﻩ‬ ‫آﻨﻴﺪ‪:‬‬ ‫))(‪Year(Now‬‬ ‫)‪Hour(time‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ از ﻣﻘﺪار زﻣﺎن‪ ،‬ﺑﺨﺶ ﺳﺎﻋﺖ ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.WriteLine(Minute(Now‬‬ ‫)‪Second(time‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ از ﻣﻘﺪار زﻣﺎن‪ ،‬ﺛﺎﻧﻴﻪ ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل دﺳﺘﻮر زﻳﺮ ﺳﺎﻋﺖ ﺟﺎري ﺳﻴﺴﺘﻢ را ﻧﺸﺎن ﻣﻲ دهﺪ‪:‬‬ ‫)))(‪Console.‬‬ ‫ﻣﻘﺪاري آﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﻣﻲ ﮔﺮداﻧﺪ ﺑﻴﻦ ‪ 0‬ﺗﺎ ‪ 24‬اﺳﺖ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،date‬ﻣﻘﺪاري از ﻧﻮع ﺗﺎرﻳﺦ اﺳﺖ آﻪ ﺳﺎل ﺁن ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،date‬ﻣﻘﺪاري از ﻧﻮع ﺗﺎرﻳﺦ اﺳﺖ آﻪ ﻣﺎﻩ ﺁن ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،time‬ﻣﻘﺪاري از ﻧﻮع زﻣﺎن اﺳﺖ آﻪ ﺛﺎﻧﻴﻪ ﺁن ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد‪.‬‬ ‫)‪Month(date‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ از ﻣﻘﺪار ﺗﺎرﻳﺦ‪ ،‬ﻣﺎﻩ ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ آﻪ ﻋﺪدي ﺑﻴﻦ ‪ 1‬ﺗﺎ ‪ 12‬اﺳﺖ‪.‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ firstdayofweek‬ﻧﻴﺰ اوﻟﻴﻦ روز هﻔﺘﻪ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ و ﻣﻲ ﺗﻮاﻧﺪ ﻳﻜـﻲ از‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ ﺁرﮔﻮﻣﺎن ‪ firstdayofweek‬از ﺗﺎﺑﻊ ‪ Weekday‬ﻣﻲ ﭘﺬﻳﺮد‪ ،‬ﺑﭙﺬﻳﺮد‪.‬‬ ‫)‪Year(date‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ از ﻣﻘﺪار ﺗﺎرﻳﺦ‪ ،‬ﺳﺎل ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،time‬ﻣﻘﺪاري از ﻧﻮع زﻣﺎن اﺳﺖ آﻪ دﻗﻴﻘﻪ ﺁن ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد‪.

WriteLine(DateValue(“December 25.‬ﭘﺲ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ‪:‬‬ ‫))‪Console.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.WriteLine((DateDiff(DateInterval.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔﺮ اﻳﻦ ﺗﺎﺑﻊ را ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺑﻪ آﺎر ﺑﺒﺮﻳﻢ‪:‬‬ ‫))”‪Console.‬‬ ‫ﺁرﮔﻮﻣﺎن هﺎي ‪ Minute ،Hour‬و ‪ Second‬ﺑﻪ ﺗﺮﺗﻴﺐ اﻋﺪاد ﺻﺤﻴﺤﻲ هﺴﺘﻨﺪ آﻪ ﺳـﺎﻋﺖ‪ ،‬دﻗﻴﻘـﻪ‬ ‫و ﺛﺎﻧﻴﻪ را آﻪ ﺑﺎﻳﺪ ﺑﻪ زﻣﺎن ﺗﺒﺪﻳﻞ ﺷﻮﻧﺪ‪ ،‬ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ‪.NET‬‬ ‫‪٣٩‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .Date).Weekday(Now.10. 2002‬‬ ‫ﻋﺒﺎرﺗﻲ آﻪ در ﺧﺮوﺟﻲ ﭼﺎپ ﻣﻲ ﺷﻮد‪ “12/25/2002” ،‬ﺧﻮاهﺪ ﺑﻮد‪.90‬‬ ‫ﺧﺮوﺟﻲ اﻳﻦ دﺳﺘﻮر‪ ،‬ﻋﺒﺎرت ”‪ “03/30/1996‬ﺧﻮاهﺪ ﺑﻮد‪.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫)‪TimeSerial(4.WriteLine(DateSerial(2002.10.‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻣﻌﻤﻮﻻ ﺑﺮاي ﻣﺤﺎﺳﺒﻪ ي زﻣﺎن ﺑﻪ آﺎر ﻣﻲ رود‪.‬ﻣﻲ ﺗﻮاﻧﻴﺪ از دﺳﺘﻮر زﻳﺮ ﺟﻬﺖ ﺁﮔﺎهﻲ از اﻳﻦ ﻣﻮﺿﻮع اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪:‬‬ ‫))‪Console.‬‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﺗﻌﺪاد روزهﺎي هﺮ ﻣﺎﻩ در اﻳﻦ ﺗﺎﺑﻊ ‪ ٣٠‬روز اﺳﺖ‪.Date).‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻓﺮض آﻨﻴﺪ ﻣﻲ ﺧﻮاهﻴﺪ ﺑﺪاﻧﻴﺪ آﻪ ﻧﻮدﻣﻴﻦ روز ﺳـﺎل در ﭼـﻪ ﺗـﺎرﻳﺨﻲ از ﺳـﺎل ﻗـﺮار‬ ‫ﺧﻮاهﺪ ﮔﺮﻓﺖ‪ .month.‬‬ ‫هﻤﭽﻨﻴﻦ از اﻳﻦ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺟﻬﺖ ﺑﺮﺧﻲ ﻣﺤﺎﺳﺒﺎت ﺑﺮ روي ﻣﻘﺪار ﺗﺎرﻳﺦ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.minutes.‬‬ ‫)‪TimeSerial(hours.WriteLine(DateSerial(1996.DateValue(“12/25/1993”).‫)‪DateSerial(year.Day.‬‬ ‫)))” ‪DateValue(“12/25/1996‬‬ ‫ﻋﺪدي آﻪ در ﺧﺮوﺟﻲ ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ‪ 1096 ،‬ﻳﻌﻨﻲ ﺗﻌﺪاد روزهـﺎي ﺑـﻴﻦ اﻳـﻦ دو ﺗـﺎرﻳﺦ ﺧﻮاهـﺪ‬ ‫ﺑﻮد‪.‬‬ ‫دﺳﺘﻮر زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫))‪Console.1.‬‬ ‫ﻳﻜﻲ از آﺎرﺑﺮدهﺎي ﺳﻮدﻣﻨﺪ و ﻣﻔﻴﺪ اﻳﻦ ﺗﺎﺑﻊ در هﻨﮕﺎﻣﻲ اﺳـﺖ آـﻪ ﺑـﺎ ﺗـﺎﺑﻊ )(‪ DateDiff‬ﺑـﻪ آـﺎر‬ ‫رود‪.‬‬ ‫ﺁرﮔﻮﻣﺎن هﺎي ‪ month،year‬و ‪ day‬ﺑﻪ ﺗﺮﺗﻴﺐ ﺳﺎل‪ ،‬ﻣﺎﻩ و روز هﺴﺘﻨﺪ‪.day‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﺳﻪ ﻋﺪد ﺻﺤﻴﺢ را ﺑﻪ ﻋﻨﻮان ورودي درﻳﺎﻓﺖ آﺮدﻩ و ﺁن را ﺑﻪ ﺗﺎرﻳﺦ ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ‪.Month(Now.‬‬ ‫ﻓﺮض آﻨﻴﺪ ﻣﻲ ﺧﻮاهﻴﻢ ﺗﻌﺪاد روزهﺎي ﺑﻴﻦ دو ﺗﺎرﻳﺦ را ﻣﺤﺎﺳﺒﻪ آﻨﻴﻢ‪:‬‬ ‫دﺳﺘﻮر زﻳﺮ اﻳﻦ آﺎر را ﺑﺮاي ﻣﺎ اﻧﺠﺎم ﻣﻲ دهﺪ‪:‬‬ ‫_ ‪Console.seconds‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﺳﻪ ﻋﺪد ﺻﺤﻴﺢ را ﺑﻪ زﻣﺎن ﻣﺸﺨﺼﻲ ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ‪.1‬‬ ‫ﺧﺮوﺟﻲ اﻳﻦ دﺳﺘﻮر‪ ،‬رﺷﺘﻪ ي ”‪ “01/10/2002‬ﺧﻮاهﺪ ﺑﻮد‪.‬‬ ‫)‪DateValue(date‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻳﻚ ﻋﺒﺎرت رﺷﺘﻪ اي را ﺑﻪ ﻋﻨﻮان ورودي درﻳﺎﻓﺖ آﺮدﻩ و ﺁن را ﺑﻪ ﻳﻚ ﻣﻘـﺪار از ﻧـﻮع ﺗـﺎرﻳﺦ‬ ‫ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ‪.Date)+1000‬‬ ‫ﺷﻤﺎ هﻤﭽﻨﻴﻦ ﻗﺎدر ﺑﻪ اﺿﺎﻓﻪ آﺮدن ﻳﺎ آﻢ آﺮدن )ﺗﻔﺮﻳﻖ آﺮدن( ﻳﻚ ﻋﺪد ﻣﺘﻨﺎﻇﺮ ﻣﺎﻩ هﺎ ﺑﻪ ﺁرﮔﻮﻣـﺎن‬ ‫‪ month‬و هﻤﭽﻨﻴﻦ ﻳﻚ ﻋﺪد ﻣﺘﻨﺎﻇﺮ ﺳﺎل ﺑﻪ ﺁرﮔﻮﻣﺎن ‪ year‬هﺴﺘﻴﺪ‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎﻟﻲ دﻳﮕـﺮ ﻣـﻲ ﺧـﻮاهﻴﻢ ﺑـﺪاﻧﻴﻢ آـﻪ ‪ ١٠٠٠‬روز ﺑﻌـﺪ از ﺗـﺎرﻳﺦ ﻓﻌﻠـﻲ ﺳﻴـﺴﺘﻢ در ﭼـﻪ‬ ‫ﺗﺎرﻳﺨﻲ ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ‪ .‬‬ ‫ﺗﺎﺑﻊ )(‪ DateDiff‬در اداﻣﻪ ﺗﻮﺿﻴﺢ دادﻩ ﻣﻲ ﺷﻮد‪.55‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻣﻘﺪار "‪ “4:10:55 AM‬را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.WriteLine(DateSerial(Year(Now.

‬‬ ‫)‪TimeSerial(16 -2.day(day1‬‬ ‫ﻧﺘﻴﺠﻪ ﻋﺒﺎرت‪ “3/2/02” ،‬ﺧﻮاهﺪ ﺑﻮد آﻪ ﻳﻚ ﺗﺎرﻳﺦ در ﻣﺎﻩ ﻣﺎرس اﺳﺖ ﻧﻪ ﻓﻮرﻳﻪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،interval‬ﻳﻚ واﺣﺪ زﻣﺎﻧﻲ هﻤﺎﻧﻨﺪ روز‪ ،‬ﺳﺎﻋﺖ‪ ،‬هﻔﺘﻪ و … اﺳﺖ آـﻪ ﻓﺎﺻـﻠﻪ دورﻩ اي را‬ ‫ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ ﺗﺎرﻳﺦ ﺟﺪﻳﺪ ﺑﺎﻳﺪ ﺑﺮ ﺣﺴﺐ ﺁن ﻣﺤﺎﺳـﺒﻪ و ﺑﺮﮔـﺸﺖ دادﻩ ﺷـﻮد و ﻣـﻲ ﺗﻮاﻧـﺪ‬ ‫ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ زﻳﺮ را ﺑﭙﺬﻳﺮد‪:‬‬ ‫ﺳﺎل ‪Year:‬‬ ‫ﻳﻚ ﭼﻬﺎرم ﺳﺎل ﻳﺎ ‪ ٣‬ﻣﺎﻩ ﻳﺎ ﻳﻚ ﻓﺼﻞ ‪Quarter:‬‬ ‫ﻣﺎﻩ ‪Month:‬‬ ‫روز از ﺳﺎل ‪DayOfYear:‬‬ ‫روز ‪Day:‬‬ ‫روز از هﻔﺘﻪ ‪WeekDay:‬‬ ‫هﻔﺘﻪ از ﺳﺎل ‪WeekOfYear:‬‬ ‫ﺳﺎﻋﺖ ‪Hour:‬‬ ‫دﻗﻴﻘﻪ ‪Minute:‬‬ ‫ﺛﺎﻧﻴﻪ ‪Second:‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،number‬ﺗﻌﺪاد هﺮ دورﻩ ي زﻣﺎﻧﻲ را ﻣﺸﺨﺺ ﻣﻲ آﻨـﺪ‪ .WriteLine(DateSerial(year(day1).13 -15.‬‬ ‫)‪DateAdd(interval.month(day1)+1.1.date‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ هﻤﺎن ﻃﻮر آﻪ از ﻧـﺎم ﺁن ﻧﻴـﺰ ﭘﻴﺪاﺳـﺖ‪ ،‬ﻣﻘـﺪاري را ﺑـﻪ ﺗـﺎرﻳﺨﻲ ﻣـﺸﺨﺺ اﺿـﺎﻓﻪ آـﺮدﻩ و‬ ‫ﺗﺎرﻳﺦ ﺟﺪﻳﺪ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻣﻲ ﺧﻮاهﻴﻢ ﺑﺪاﻧﻴﻢ آﻪ ‪ ١‬ﻣﺎﻩ ﺑﻌﺪ از ‪ ٣١‬دﺳـﺎﻣﺒﺮ ﺳـﺎل ‪ ،٢٠٠٢‬ﭼـﻪ ﺗـﺎرﻳﺨﻲ ﻣـﻲ‬ ‫ﺷﻮد‪ .Month.‬ﭘﺲ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ‪:‬‬ ‫))‪Console.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫‪day1 =#1/31/2002#‬‬ ‫)))‪Console.WriteLine(DateAdd(DateInterval.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ date‬ﻧﻴﺰ ﺗﺎرﻳﺨﻲ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ ﻋﻤﻠﻴﺎت ﺑﺎﻳﺪ ﺑﺮ روي ﺁن اﻧﺠﺎم ﺷﻮد‪.NET‬‬ ‫‪٤٠‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .number.‬‬ ‫)‪TimeValue(time‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي را درﻳﺎﻓﺖ آﺮدﻩ و ﺁن را ﺑﻪ ﻣﻘﺪار زﻣﺎﻧﻲ ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ‪.40 -32‬‬ ‫زﻣﺎن ﺑﺮﮔﺸﺘﻲ‪ 1:58:08 PM ،‬ﺧﻮاهﺪ ﺑﻮد‪.‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﺎ ﺣﺪ زﻳﺎدي ﺷﺒﻴﻪ ﺑﻪ ﺗﺎﺑﻊ )(‪ DateSerial‬اﺳﺖ آﻪ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪ ﺑﺎ اﻳـﻦ ﺗﻔـﺎوت آـﻪ‬ ‫ﺗﻌﺪاد روزهﺎي هﺮ ﻣﺎﻩ در اﻳﻦ ﺗﺎﺑﻊ ﺑﻨﺎ ﺑﻪ ﻧﺎم ﻣﺎﻩ ﻓﺮق ﻣﻲ آﻨﺪ ﻣﺜﻼ ﻣﻤﻜﻦ اﺳﺖ ﻳﻚ ﻣﺎﻩ ‪ ٣٠‬ﻳـﺎ ‪٣١‬‬ ‫روز ﺑﺎﺷﺪ اﻣﺎ ﺗﻌﺪاد روزهﺎي ﻣﺎﻩ در ﺗﺎﺑﻊ )(‪ ،DateSerial‬ﺛﺎﺑﺖ و ‪ ٣٠‬روز ﻣﻲ ﺑﺎﺷﺪ‪.#12/31/2002#‬‬ ‫ﻧﺘﻴﺠﻪ اﻳﻦ دﺳﺘﻮر‪ ،‬ﻋﺒﺎرت ”‪ “1/31/2003 12:00:00 AM‬ﺧﻮاهﺪ ﺑﻮد‪.‬‬ ‫ﻧﻜﺘﻪ‪ :‬اﮔﺮ اﻳﻦ ﺁرﮔﻮﻣﺎن ﻋﺪدي ﻣﺜﺒﺖ ﺑﺎﺷﺪ‪ ،‬ﺗﺎرﻳﺨﻲ آﻪ ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﺪ ﺷﺪ ﻣﺮﺑﻮط ﺑـﻪ ﺁﻳﻨـﺪﻩ‬ ‫اﺳﺖ و اﮔﺮ اﻳﻦ ﺁرﮔﻮﻣﺎن‪ ،‬ﻣﻨﻔﻲ ﺑﺎﺷﺪ‪ ،‬ﺗﺎرﻳﺨﻲ آﻪ ﻧﺸﺎن دادﻩ ﻣﻲ ﺷﻮد ﻣﺮﺑﻮط ﺑـﻪ ﮔﺬﺷـﺘﻪ ﻣـﻲ‬ ‫ﺑﺎﺷﺪ‪.‬‬ ‫هﻤﺎﻧﻨﺪ ﺗﺎﺑﻊ )(‪ ،DateValue‬اﻳﻦ ﺗﺎﺑﻊ ﻧﻴﺰ ﻣﻲ ﺗﻮاﻧﺪ ﺟﻬﺖ اﻧﺠـﺎم ﻋﻤﻠﻴـﺎﺗﻲ ﻧﻈﻴـﺮ ﺟﻤـﻊ ﻳـﺎ ﺗﻔﺮﻳـﻖ‬ ‫زﻣﺎن هﺎ ﺑﻪ آﺎر رود‪.‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪ ،‬ﻓﺮاﺧﻮاﻧﻲ ﺗﺎﺑﻊ )(‪ TimeSerial‬ﺑﻪ ﺷﻜﻞ زﻳـﺮ‪ ٢ ،‬ﺳـﺎﻋﺖ و ‪ ١٥‬دﻗﻴﻘـﻪ و ‪ ٣٢‬ﺛﺎﻧﻴـﻪ‬ ‫ﻗﺒﻞ از ﺳﺎﻋﺖ ‪ 4:13:40 PM‬را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬ﻣـﺜﻼ ﻣﻤﻜـﻦ اﺳـﺖ ﺑﺨـﻮاهﻴﻢ‬ ‫ﺑﺪاﻧﻴﻢ آﻪ ‪ ٣‬ﻣﺎﻩ ﺑﻌﺪ از ﺗﺎرﻳﺦ ﻓﻌﻠﻲ ﺳﻴﺴﺘﻢ ﭼﻪ ﺗﺎرﻳﺨﻲ ﻣﻲ ﺷﻮد ﭘﺲ اﻳﻦ ﭘـﺎراﻣﺘﺮ را ﺑﺮاﺑـﺮ ﺑـﺎ ‪٣‬‬ ‫ﻗﺮار ﻣﻲ دهﻴﻢ‪.

firstweekofyear‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﺷﻜﻞ ﭘﻴﺸﺮﻓﺘﻪ ﺗﺮ ﺗﺎﺑﻊ )(‪ DateAdd‬اﺳﺖ و اﺧﺘﻼف ﺑﻴﻦ دو ﺗﺎرﻳﺦ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.day1‬‬ ‫‪23‬‬ ‫))‪Console.WriteLine(DatePart(“yyyy ”.‬‬ ‫ﻧﻜﺘﻪ‪ :‬هﻤﻴﺸﻪ ﻣﻘﺪار ‪ date2‬از ‪ date1‬آﻢ ﻣﻲ ﺷﻮد‪.‬‬ ‫ﺁرﮔﻮﻣﺎن هﺎي اﺧﺘﻴﺎري ‪ firstdayofweek‬و ‪ firstweekofyear‬ﻧﻴﺰ ﺑﻪ ﺗﺮﺗﻴﺐ‪ ،‬اوﻟﻴﻦ روز هﻔﺘـﻪ و‬ ‫اوﻟﻴﻦ هﻔﺘﻪ ﺳﺎل را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﻨﺪ‪.‬‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ اﻳﻦ ﺁرﮔﻮﻣﺎن هﺎ ﻣﻲ ﺗﻮاﻧﻨﺪ ﺑﭙﺬﻳﺮﻧـﺪ‪ ،‬هﻤـﺎن ﻣﻘـﺎدﻳﺮ ﺁرﮔﻮﻣـﺎن ‪ firstdayofweek‬از‬ ‫ﺗﺎﺑﻊ )(‪ Format‬اﺳﺖ آﻪ ﭘﻴﺸﺘﺮ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪ‪) .Day.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ interval‬ﺑﺨﺸﻲ اﺳﺖ آﻪ ﺑﺎﻳﺪ از ﺗﺎرﻳﺦ اﺳﺘﺨﺮاج ﺷﻮد و هﻤﺎن ﻣﻘﺎدﻳﺮي را ﻣـﻲ ﭘـﺬﻳﺮد‬ ‫آﻪ ﻣﻲ ﺗﻮان ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ ﺗﺎرﻳﺦ و زﻣﺎن در ﺗﺎﺑﻊ )(‪ Format‬ﺑﻪ آﺎر ﺑﺮد‪.date1.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻓﺮض ﻣﻲ آﻨﻴﻢ ﺗﺎرﻳﺦ ﺟﺎري ﺳﻴﺴﺘﻢ‪ ٢٣ ،‬اآﺘﺒﺮ ﺳﺎل ‪ ٢٠٠١‬ﻣﻴﻼدي اﺳﺖ‪.firstweekofyear‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﺑﺨﺸﻲ از ﻳﻚ ﺗﺎرﻳﺦ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.WriteLine(DatePart(“ww ”.WriteLine(DatePart(“q ”.day1‬‬ ‫‪10‬‬ ‫))‪Console.day1‬‬ ‫‪43‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬اﻳﺠﺎد ﻣﻲ ﺷﻮﻧﺪ‪ ،‬آﺎرﺑﺮد ﻓﺮاواﻧﻲ دارﻧﺪ‪.date [.Now‬‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ‪ :‬ﺗﻮاﺑﻊ ‪ DateDiff‬و ‪ TimeSerial‬در ﭘﺮوژﻩ هـﺎي وب و ﻣﺨـﺼﻮﺻﺎ ﻓـﻮروم هـﺎﻳﻲ آـﻪ ﺑـﻪ‬ ‫وﺳﻴﻠﻪ ي زﺑﺎن ‪ ASP.‬‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ اﻳﻦ ﺁرﮔﻮﻣﺎن ﻣﻲ ﺗﻮاﻧﺪ ﺑﭙﺬﻳﺮد هﻤﺎن ﻣﻘﺎدﻳﺮي هﺴﺘﻨﺪ آﻪ ﺁرﮔﻮﻣـﺎن ‪ interval‬ﺗـﺎﺑﻊ‬ ‫)(‪ DateAdd‬ﻣﻲ ﺗﻮاﻧﺪ ﺑﭙﺬﻳﺮد‪.day1‬‬ ‫‪3‬‬ ‫))‪Console.date2 [.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ date‬ﻧﻴﺰ ﺗﺎرﻳﺨﻲ اﺳﺖ آﻪ ﻗﺴﻤﺘﻲ از ﺁن ﺑﺎﻳﺪ اﺳﺘﺨﺮاج ﺷﻮد‪.WriteLine(DatePart(“d ”.‬‬ ‫دﺳﺘﻮرات زﻳﺮ ﻧﺘﺎﻳﺞ ﻣﺨﺘﻠﻔﻲ را ﺑﻪ ﻣﺎ ﻧﺸﺎن ﻣﻲ دهﻨﺪ آﻪ ﻧﺘﻴﺠﻪ ﺑﻪ ﺻﻮرت ﭘﺮرﻧﮓ ﺗـﺮ ﻧﻤـﺎﻳﺶ دادﻩ‬ ‫ﺷﺪﻩ اﺳﺖ‪:‬‬ ‫‪Dim Day1 As DateTime‬‬ ‫)(‪day1 =Now‬‬ ‫))‪Console.‫)]] ‪DateDiff(interval.‬‬ ‫ﻳﻚ ﻧﻜﺘﻪ ي ﺑﺴﻴﺎر ﻣﻬﻢ‪ :‬ﻧﻜﺘﻪ اي آﻪ ﻣﺘﺎﺳﻔﺎﻧﻪ در اآﺜﺮ ﭘﺮوژﻩ هﺎي وب در اﻳﺮان رﻋﺎﻳﺖ ﻧﻤﻲ ﺷﻮد‬ ‫اﻳﻦ اﺳﺖ آﻪ ﺳﺎﻋﺖ رﺳﻤﻲ اﻳﺮان در روز اول ﻓﺮوردﻳﻦ ﻳﻚ ﺳﺎﻋﺖ ﺑﻪ ﺟﻠـﻮ آـﺸﻴﺪﻩ ﻣـﻲ ﺷـﻮد و‬ ‫در اﻳﻦ ﺣﺎﻟﺖ‪ ،‬ﺳﺎﻋﺖ آﺸﻮر ﻣﺎ از ﮔﺮﻳﻨﻮﻳﭻ‪ ٤:٣٠ ،‬ﺳـﺎﻋﺖ ﺟﻠـﻮﺗﺮ اﺳـﺖ‪ ،‬در ﺣـﺎﻟﻲ آـﻪ در روز ‪٣١‬‬ ‫ﺷﻬﺮﻳﻮر ﻳﻚ ﺳﺎﻋﺖ ﺑﻪ ﻋﻘﺐ آﺸﻴﺪﻩ ﻣﻲ ﺷﻮد و ﺑﻪ ﺣﺎﻟﺖ اوﻟﻴﻪ ﺧﻮد ﺑﺎز ﻣﻲ ﮔﺮدد ﻳﻌﻨـﻲ ‪+3.‬‬ ‫ﻣﺜﺎل زﻳﺮ ﺗﻌﺪاد روزهﺎي ﺑﻴﻦ ﻳﻚ ﺗﺎرﻳﺦ ﻣﺸﺨﺺ ﺷﺪﻩ و ﺗﺎرﻳﺦ ﻓﻌﻠﻲ ﺳﻴﺴﺘﻢ را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪:‬‬ ‫‪Dim century As Date‬‬ ‫‪century =#1/1/2000#‬‬ ‫)))(‪MsgBox(DateDiff(DateInterval.‬‬ ‫ﺁرﮔﻮﻣـــﺎن هـــﺎي اﺧﺘﻴـــﺎري ‪ firstdayofweek‬و ‪ firstweekofyear‬ﻧﻴـــﺰ در ﺗـــﺎﺑﻊ )(‪DateDiff‬‬ ‫ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻧﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن هﺎي ‪ date1‬و ‪ date2‬ﺗﺎرﻳﺦ هﺎﻳﻲ هﺴﺘﻨﺪ آﻪ اﺧﺘﻼف ﺁﻧﻬﺎ ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد‪.day1‬‬ ‫‪2001‬‬ ‫))‪Console.firstdayofweek [.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ interval‬ﻳﻚ ﻣﻘﺪار ﺛﺎﺑﺖ اﺳﺖ و ﻓﻮاﺻـﻞ ﺑـﻴﻦ دورﻩ اي را ﻣـﺸﺨﺺ ﻣـﻲ آﻨـﺪ آـﻪ ﺷـﻤﺎ‬ ‫ﺑﺮاي ﻣﺤﺎﺳﺒﻪ اﺧﺘﻼف ﺑﻴﻦ دو ﺗﺎرﻳﺦ ﺑﻪ آﺎر ﻣﻲ ﺑﺮﻳﺪ‪.WriteLine(DatePart(“m ”.firstdayofweek [.WriteLine(DatePart(“w ”.day1‬‬ ‫‪3‬‬ ‫))‪Console.‬ﺑﻪ ﺗﻮﺿﻴﺤﺎت ﺗﺎﺑﻊ )(‪ format‬ﻣﺮاﺟﻌﻪ آﻨﻴﺪ(‬ ‫ﻣﺜﻼ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ از اﻳﻦ ﺗﺎﺑﻊ ﺑﺮاي اﻃﻼع از ﺗﻌﺪاد روزهﺎ‪ ،‬هﻔﺘﻪ هﺎ‪ ،‬ﺛﺎﻧﻴﻪ هﺎ و … ﺑﻴﻦ دو ﺗـﺎرﻳﺦ‬ ‫اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.5‬‬ ‫‪GMT‬‬ ‫)]] ‪DatePart(interval.NET‬‬ ‫‪٤١‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .century.

day1)) 3 Console.WriteLine(DatePart(“h ”.NET ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ‬ .WriteLine(DatePart(“n ”.day1)) 15 Console.day1)) 30 ‫ ﺑﻬﺮوز راد‬:‫ﺑﻪ وﺳﻴﻠﻪ‬ ٤٢ Visual Basic.Console.WriteLine(DatePart(“s ”.

‬‬ ‫ﻋﻤﻞ ﺧﻮاﻧﺪن ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ‪ ،‬ﺑﻪ ﺗﺮﺗﻴﺐ ﻳﻌﻨﻲ از اﺑﺘﺪا ﺗﺎ اﻧﺘﻬﺎي ﻓﺎﻳﻞ و ﺧﻂ ﺑﻪ ﺧـﻂ اﻧﺠـﺎم ﻣـﻲ‬ ‫ﺷﻮد ﺑﻨﺎﺑﺮاﻳﻦ ﺷﻤﺎ ﻧﻤﻲ ﺗﻮاﻧﻴﺪ در ﻳﻚ زﻣﺎن در ﻳـﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ هـﻢ اﻃﻼﻋـﺎت را ﺑﺨﻮاﻧﻴـﺪ و هـﻢ‬ ‫اﻃﻼﻋﺎت را ﺑﻨﻮﻳﺴﻴﺪ‪.‬‬ ‫در وﻳﮋوال ﺑﻴﺴﻴﻚ‪ ٣ ،‬ﻧﻮع ﻓﺎﻳﻞ وﺟﻮد دارد‪:‬‬ ‫‪ (١‬ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ‪.‬‬ ‫اﮔﺮ ﻗﺼﺪ ﺧﻮاﻧـﺪن و ﻧﻮﺷـﺘﻦ هﻤﺰﻣـﺎن در و از ﻳـﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ را دارﻳـﺪ‪ ،‬ﺑﺎﻳـﺪ از دو ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ‬ ‫اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪ .‬‬ ‫ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ اﻏﻠﺐ ﻓﺎﻳـﻞ هـﺎي ﻣﺘﻨـﻲ )‪ (Text‬هـﺴﺘﻨﺪ‪ .‬‬ ‫در ﻓﺎﻳﻞ هﺎي ﺗـﺼﺎدﻓﻲ اﻃﻼﻋـﺎت را ﻣـﻲ ﺗـﻮان در هـﺮ ﺟـﺎي ﻓﺎﻳـﻞ ﻧﻮﺷـﺖ ﺑـﺪون ﺁﻧﻜـﻪ هﻤﺠـﻮاري‬ ‫رآﻮردهﺎ از ﺑﻴﻦ ﺑﺮود ﻳﺎ ﻟﻄﻤﻪ اي ﺑﺨﻮرد‪.Double‬‬ ‫ﺑﺮاي ﻧﻤﺎﻳﺶ ﻓﺎﻳـﻞ هـﺎي ﺗـﺼﺎدﻓﻲ در ﻣﺤـﻴﻂ ‪ Dos‬ﻣـﻲ ﺗﻮاﻧﻴـﺪ ﺑـﺎ ﻧﻮﺷـﺘﻦ دﺳـﺘﻮر ‪ TYPE‬در ﺧـﻂ‬ ‫ﻓﺮﻣﺎن‪ ،‬ﻣﻘﺎدﻳﺮ رﺷﺘﻪ اي ذﺧﻴﺮﻩ ﺷﺪﻩ در اﻳﻦ ﻓﺎﻳﻞ هﺎ را ﻣﺸﺎهﺪﻩ آﻨﻴـﺪ اﻣـﺎ ﻗـﺎدر ﺑـﻪ دﻳـﺪن اﻋـﺪاد‬ ‫ذﺧﻴﺮﻩ ﺷﺪﻩ ﻧﻴﺴﺘﻴﺪ‪.‬‬ ‫ﻓﺎﻳﻞ هﺎي ﺗﺼﺎدﻓﻲ ﺑﻪ ﺷﻤﺎ اﻳﻦ اﻣﻜﺎن را ﻣﻲ دهﻨﺪ آﻪ ﺑﻪ هﺮ رآﻮرد دﻟﺨـﻮاﻩ در ﻓﺎﻳـﻞ ﺑـﻪ ﺳـﺮﻋﺖ‬ ‫دﺳﺘﺮﺳﻲ داﺷﺘﻪ ﺑﺎﺷﻴﺪ‪.‫ﺗﻮاﺑﻌﻲ آﻪ ﺟﻬﺖ اﻧﺠﺎم ﻋﻤﻠﻴﺎت ورودي‪/‬ﺧﺮوﺟﻲ )‪ (I/O‬ﺑﺮ روي ﻓﺎﻳﻞ هﺎ ﻣﻮرد‬ ‫اﺳﺘﻔﺎدﻩ ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ )‪:(File I/O‬‬ ‫ﻳﻜﻲ از ﺟﻨﺒﻪ هﺎي ﻣﻬﻢ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ در هﺮ زﺑﺎن‪ ،‬ﻗﺎﺑﻠﻴﺖ دﺳﺘﺮﺳﻲ و ﻣـﺪﻳﺮﻳﺖ ﻓﺎﻳـﻞ هـﺎ ﻣـﻲ‬ ‫ﺑﺎﺷﺪ‪.‬ﺑـﻪ ﻋﺒـﺎرت دﻳﮕـﺮ ﺷـﻤﺎ ﻣـﻲ ﺗﻮاﻧﻴـﺪ‬ ‫اﻳﻨﮕﻮﻧﻪ ﻓﺎﻳﻞ هﺎ را ﺑﺎ هﺮ وﻳﺮاﻳﺸﮕﺮ ﻣﺘﻨﻲ هﻤﺎﻧﻨﺪ ‪ Notepad‬ﺑﺎز آﻨﻴﺪ‪.‬‬ ‫اﮔﺮ در ﺑﺮﻧﺎﻣﻪ اي آﻪ ﻣﻲ ﻧﻮﻳﺴﻴﺪ ﺑﻪ ﻃﻮر ﻣﻜﺮر ﺑﺎ ﻓﺎﻳﻞ هـﺎ ﺳـﺮو آـﺎر دارﻳـﺪ ﺑـﻪ ﮔﻮﻧـﻪ اي آـﻪ ﺑﺎﻳـﺪ‬ ‫ﻣﺮﺗﺒﺎ ﻣﺤﺘﻮﻳﺎت ﻳﻚ ﻓﺎﻳﻞ ﺧﻮاﻧﺪﻩ ﺷﻮد و ﭘﺲ از اﻧﺠـﺎم ﺗﻐﻴﻴـﺮات ﻣﺠـﺪدا ذﺧﻴـﺮﻩ ﺷـﻮد‪ ،‬ﺑﺎﻳـﺪ از ﻓﺎﻳـﻞ‬ ‫هﺎي ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.‬‬ ‫ﻣﺤﺘﻮﻳﺎت اﻳﻦ ﻓﺎﻳﻞ هﺎ ﻣﻲ ﺗﻮاﻧﺪ هﺮ ﭼﻴﺰي ﺑﺎﺷﺪ‪.‬‬ ‫ﻣﺜﻼ ﻣﻘﺎدﻳﺮ ﻋﺪدي ﺑﻪ ﺻﻮرت ‪ Integer‬ﻳﺎ ‪ Double‬ذﺧﻴﺮﻩ ﻧﻤـﻲ ﺷـﻮﻧﺪ ﺑﻠﻜـﻪ ﺑـﻪ ﺻـﻮرت ‪String‬‬ ‫ﻋﻤﻞ ذﺧﻴﺮﻩ ﺳﺎزي ﺁﻧﻬﺎ اﻧﺠﺎم ﻣﻲ ﺷﻮد‪.‬‬ ‫‪ (٢‬ﻓﺎﻳﻞ هﺎي ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ‪.‬‬ ‫اﻧﺠﺎم ﻋﻤﻠﻴﺎت ﺑﺮ روي ﻓﺎﻳﻞ هﺎ ﺑﺪون در ﻧﻈﺮ ﮔﺮﻓﺘﻦ ﻧﻮع ﺁﻧﻬﺎ‪ ،‬ﺑﻪ ﻃـﻮر آﻠـﻲ ﺷـﺎﻣﻞ ‪ ٣‬ﻣﺮﺣﻠـﻪ ﻣـﻲ‬ ‫ﺑﺎﺷﺪ‪:‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬ ‫‪٤٣‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﻓﺎﻳﻞ هﺎي ﺑﺎﻳﻨﺮي‪ :‬اﻳﻨﮕﻮﻧﻪ ﻓﺎﻳﻞ هﺎ ﺷﺒﻴﻪ ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ هﺴﺘﻨﺪ‪.‬‬ ‫اﻳﻦ ﺑﺨﺶ هﺎ را اﺻﻄﻼﺣﺎ رآﻮرد ﻣﻲ ﻧﺎﻣﻴﻢ‪.‬‬ ‫ﺗﻤﺎﻣﻲ اﻃﻼﻋﺎت ذﺧﻴﺮﻩ ﺷﺪﻩ در ﻓﺎﻳﻞ هﺎي ﻣﺘﻨﻲ ﺑﻪ ﺻﻮرت رﺷﺘﻪ اي ذﺧﻴﺮﻩ ﺧﻮاهﻨﺪ ﺷﺪ‪.‬‬ ‫در اﻳﻨﮕﻮﻧﻪ ﻓﺎﻳﻞ هﺎ هﺮ آﺎراآﺘﺮ ذﺧﻴﺮﻩ ﺷﺪﻩ در ﻓﺎﻳﻞ‪ ،‬ﻳﻚ ﺑﺎﻳﺖ را اﺷﻐﺎل ﻣﻲ آﻨﺪ‪.‬‬ ‫در اﻳﻦ ﻧﻮع ﻓﺎﻳﻞ هﺎ‪ ،‬دادﻩ هﺎ ﺑﻪ ﺻﻮرت ﺑﺎﻳﻨﺮي ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬ ‫ﻓﺎﻳﻞ هﺎي ﺗﺼﺎدﻓﻲ ﻧﻴﺰ هﻤﺎﻧﻨﺪ ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒـﻲ ﺑـﺮاي ﻣﻘـﺎدﻳﺮي از ﻧـﻮع رﺷـﺘﻪ اي ﺑـﻪ ازاي هـﺮ‬ ‫آﺎراآﺘﺮ‪ ،‬ﻳﻚ ﺑﺎﻳﺖ را اﺧﺘﺼﺎص ﻣﻲ دهﻨﺪ اﻣﺎ ﺑـﺮ ﺧـﻼف ﻓﺎﻳـﻞ هـﺎي ﺗﺮﺗﻴﺒـﻲ‪ ،‬در اﻳـﻦ ﻧـﻮع ﻓﺎﻳـﻞ هـﺎ‬ ‫ﻣﻘﺎدﻳﺮ ﻋﺪدي ﺑﺎ ﻧﻮع ﺧﺎص ﺧﻮد ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ ﻣﺜﻼ ‪ Integer‬ﻳﺎ ‪.‬‬ ‫ﻓﺎﻳﻞ هﺎي ﺗﺼﺎدﻓﻲ ﺑﺮاي ذﺧﻴﺮﻩ آﺮدن دادﻩ هﺎﻳﻲ آـﻪ در ﺑﺨـﺶ هـﺎﻳﻲ ﺑـﺎ ﻃـﻮل ﻣـﺸﺨﺺ دﺳـﺘﻪ‬ ‫ﺑﻨﺪي ﺷﺪﻩ اﻧﺪ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‪.‬‬ ‫ﻣﺜﻼ ﻋﺪد ‪ ٤٢٦‬ﻋﺪدي از ﻧﻮع ﺻﺤﻴﺢ اﺳﺖ و ﭼﻮن اﻋﺪاد ﺻﺤﻴﺢ دو ﺑﺎﻳﺖ از ﺣﺎﻓﻈـﻪ را اﺷـﻐﺎل ﻣـﻲ‬ ‫آﻨﻨﺪ ﭘﺲ ﻣﻴﺰان ﻓﻀﺎي اﺧﺘﺼﺎص ﻳﺎﻓﺘﻪ ﺑﻪ اﻳﻦ ﻋﺪد در اﻳﻦ ﻧﻮع ﻓﺎﻳﻞ‪ ٢ ،‬ﺑﺎﻳﺖ اﺳﺖ‪.‬‬ ‫آﺎراآﺘﺮ‪ ،‬ﻋﺪد ﻳﺎ ﺣﺘﻲ ﺗﺼﺎوﻳﺮ ﻣﻲ ﺗﻮاﻧﻨﺪ در ﻓﺎﻳﻞ هﺎي ﺑﺎﻳﻨﺮي ذﺧﻴﺮﻩ ﺷﻮﻧﺪ‪.‬‬ ‫اﻳﻦ ﻓﺎﻳﻞ هﺎ در ﻣﻘﺎﻳﺴﻪ ﺑﺎ ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ از ﺳﺮﻋﺖ ﺑﻴﺸﺘﺮي ﺑﺮﺧﻮردارﻧﺪ‪.‬‬ ‫‪ (٣‬ﻓﺎﻳﻞ هﺎي ﺑﺎﻳﻨﺮي‪.‬‬ ‫ﻓﺎﻳﻞ هﺎي ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ ﺑﺮﺧﻼف ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ ﻣﻲ ﺗﻮاﻧﻨﺪ در ﻳﻚ زﻣـﺎن‪ ،‬هـﻢ ﻓﺎﻳـﻞ را‬ ‫ﺑﺨﻮاﻧﻨﺪ و هﻢ در ﺁن ﺑﻨﻮﻳﺴﻨﺪ‪.‬‬ ‫از ﺁﻧﺠﺎﻳﻲ آﻪ ﺗﻤﺎﻣﻲ رآﻮردهﺎ در ﻓﺎﻳﻞ ﺗﺼﺎدﻓﻲ داراي ﻃـﻮل ﺛـﺎﺑﺘﻲ هـﺴﺘﻨﺪ‪ ،‬اﺿـﺎﻓﻪ آـﺮدن رآـﻮرد‬ ‫ﺟﺪﻳﺪ در ﻓﺎﻳﻞ ﺑﺎ اﺧﺘﺼﺎص دادن ﻳﻚ ﺷﻤﺎرﻩ ﺷﺎﺧﺺ )‪ (index‬ﺑﻪ اﻳﻦ رآﻮرد ﺑﺴﻴﺎر ﺁﺳﺎن اﺳﺖ‪.‬ﻳﻜﻲ ﺑﺮاي ﺧﻮاﻧﺪن اﻃﻼﻋﺎت و ﻳﻜﻲ ﺑﺮاي ﻧﻮﺷﺘﻦ اﻃﻼﻋﺎت درون ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ‪.

file1‬‬ ‫)‪FileOpen(fNum2.dat”. file2‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.OpenMode. file2‬‬ ‫دﺳﺘﻮر دوم اﺷﺘﺒﺎﻩ اﺳﺖ ﭼﻮن هﺮ وﻗﺖ آـﻪ ﺗـﺎﺑﻊ )(‪ FreeFile‬ﺑـﺮاي ﺗﻌﻴـﻴﻦ ﺷـﻤﺎرﻩ ي ﻳـﻚ ﻓﺎﻳـﻞ‬ ‫ﺟﺪﻳﺪ ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ ﺷﻮد ﺑﺎﻳﺪ ﻣﻮرد اﺳﺘﻔﺎدﻩ ﻗﺮار ﺑﮕﻴﺮد و ﻧﻤﻲ ﺗﻮان ﻗﺒﻞ از ﺑﻪ آﺎرﮔﻴﺮي ﺁن دوﺑﺎرﻩ‬ ‫از هﻤﻴﻦ ﺗﺎﺑﻊ ﺟﻬﺖ اﻳﺠﺎد ﻳﻚ ﺷﻤﺎرﻩ ﺟﺪﻳﺪ اﺳﺘﻔﺎدﻩ آﺮد‪.NET‬‬ ‫‪٤٤‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل دﺳﺘﻮرات زﻳﺮ آﺎر ﻧﻤﻲ آﻨﻨﺪ‪:‬‬ ‫)(‪fNum1 =FreeFile‬‬ ‫)(‪fNum2 =FreeFile‬‬ ‫)‪FileOpen(fNum1.‬‬ ‫دﺳﺘﻮر زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫)(‪fNum =FreeFile‬‬ ‫)‪FileOpen(fNum.‬‬ ‫ﺑﺴﺘﻦ ﻓﺎﻳﻞ‪ :‬هﻨﮕﺎﻣﻲ آﻪ آﺎر ﺑﺎ ﻓﺎﻳﻞ ﺑﻪ اﺗﻤﺎم رﺳﻴﺪ ﺑﺎﻳﺪ ﺁن را ﺑﺴﺖ‪ .‬‬ ‫ﭘﺮدازش ﻓﺎﻳﻞ‪ :‬ﻳﻚ ﻓﺎﻳﻞ ﻣﻲ ﺗﻮاﻧـﺪ ﺑـﺮاي ﺧﻮاﻧـﺪن‪ ،‬ﻧﻮﺷـﺘﻦ و ﻳـﺎ ﺧﻮاﻧـﺪن‪-‬ﻧﻮﺷـﺘﻦ هﻤﺰﻣـﺎن دادﻩ‬ ‫هﺎﻳﺶ ﺑﺎز ﺷﻮد‪.‬هﻨﮕﺎﻣﻲ آﻪ ﻓﺎﻳـﻞ ﺑـﺴﺘﻪ‬ ‫ﺷﺪ‪ ،‬ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﻓﻀﺎي اﺧﺘﺼﺎص دادﻩ ﺷﺪﻩ ﺑﻪ ﻓﺎﻳﻞ را ﺑﻪ ﺣﺎﻓﻈﻪ اﺻﻠﻲ ﺑﺎز ﻣﻲ ﮔﺮداﻧﺪ‪.‬‬ ‫اﮔﺮ ﺑﺮﻧﺎﻣﻪ ي ﺷﻤﺎ در ﻃﻮل دورﻩ آﺎري ﺧﻮد ﺗﻌﺪاد زﻳـﺎدي ﻓﺎﻳـﻞ را ﺑـﺎز ﻳـﺎ ﺑـﺴﺘﻪ ﻣـﻲ آﻨـﺪ‪ ،‬ﻣﻤﻜـﻦ‬ ‫ﻧﻴﺴﺖ آﻪ ﺷﻤﺎ هﻤﻴﺸﻪ ﺷﻤﺎرﻩ ﻓﺎﻳﻞ ﻳﺎ ﻓﺎﻳﻞ هﺎﻳﻲ را آﻪ هﻢ اآﻨﻮن ﺑﺎز هﺴﺘﻨﺪ ﺑﺪاﻧﻴﺪ‪.‬اﮔﺮ ﻓﺎﻳﻞ وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ‪ ،‬اﺑﺘـﺪا ﺳـﺎﺧﺘﻪ ﺷـﺪﻩ و ﺳـﭙﺲ ﺑـﺎز ﻣـﻲ‬ ‫ﺷﻮد‪.‬‬ ‫ﻧﻜﺘﻪ‪ :‬ﺗﺎﺑﻊ )(‪ FreeFile‬را ﻧﻤﻲ ﺗﻮان ﺑﻪ ﻃﻮر ﻣﺴﺘﻘﻴﻢ در ﺗﺎﺑﻊ )(‪ OpenFile‬ﺑﻪ آﺎر ﺑﺮد‪. ”C:\MyFile.‬‬ ‫در ‪ ،VB‬ﺗﺎﺑﻊ )(‪ FreeFile‬ﺷﻤﺎرﻩ ﻓﺎﻳﻠﻲ ﺑﻌﺪي را آﻪ ﻗﺮار اﺳﺖ ﺑﺎز ﺷﻮد ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ‪.‬‬ ‫ﺑﺮاي ﺑﺴﺘﻦ ﻳﻚ ﻓﺎﻳﻞ ﺑﺎز از ﺗﺎﺑﻊ )(‪ FileClose‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.‬‬ ‫دادﻩ هﺎﻳﻲ آﻪ ﺧﻮاﻧﺪﻩ ﻣﻲ ﺷﻮﻧﺪ‪ ،‬ﭘﺮدازش ﺷﺪﻩ و ﺳﭙﺲ در هﻤﺎن ﺟﺎي ﻗﺒﻠﻲ ﻳﺎ در ﻓﺎﻳﻞ دﻳﮕﺮي‬ ‫ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬ ‫هﻤﺎن ﻃﻮر آﻪ ﮔﻔﺘﻪ ﺷﺪ اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﺷﻤﺎرﻩ ﻓﺎﻳﻞ ﺑﻌﺪي را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ ﻣﮕﺮ اﻳﻨﻜﻪ اﻳﻦ ﺷﻤﺎرﻩ ﺑـﻪ‬ ‫ﻓﺎﻳﻠﻲ اﺧﺘﺼﺎص دادﻩ ﺷﺪﻩ ﺑﺎﺷﺪ‪ .‬‬ ‫)‪FreeFile(file_number‬‬ ‫هﺮ ﻓﺎﻳﻠﻲ آﻪ ﺑﺎز ﻣﻲ ﺷﻮد ﺑﺎﻳﺪ ﺷﻤﺎرﻩ اي ﺑﻪ ﺁن اﺧﺘﺼﺎص ﻳﺎﺑﺪ‪. fileName‬‬ ‫ﺑﻌﺪ از اﺟﺮاي اﻳﻦ دو دﺳﺘﻮر‪ ،‬هﺮ ﻓﺮﻣﺎﻧﻲ آﻪ ﺑﺎ ﻓﺎﻳﻞ ﺳﺮوآﺎر داﺷﺘﻪ ﺑﺎﺷﺪ ﻣﻲ ﺗﻮاﻧﺪ ﺑـﺎ ﺁوردن ﻧـﺎم‬ ‫‪ fNum‬در ﺁرﮔﻮﻣﺎن ﻣﺮﺑﻮﻃﻪ ي ﺧﻮد‪ ،‬ﺑﻪ اﻳﻦ ﻓﺎﻳﻞ دﺳﺘﺮﺳﻲ داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬ ‫ﺑﺮاي ﺑﺎزآﺮدن ﻳﺎ در ﺻﻮرت ﻟﺰوم‪ ،‬اﻳﺠﺎد ﻳﻚ ﻓﺎﻳﻞ از ﺗﺎﺑﻊ )(‪ FileOpen‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪. file1‬‬ ‫)(‪fNum2 =FreeFile‬‬ ‫)‪FileOpen(fNum.‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ هﻤﻴﺸﻪ ﺑﺎ ﺗﺎﺑﻊ )(‪ FileOpen‬ﺟﻬﺖ ﺑﺎزآﺮدن ﻳﻚ ﻓﺎﻳﻞ ﺑﻪ آﺎر ﻣﻲ رود‪.‬‬ ‫دﺳﺘﻮر زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫)‪FileOpen(FreeFile().Input‬‬ ‫اﻳﻦ دﺳﺘﻮر از ﻧﻈﺮ ﻧﺤﻮي درﺳﺖ آﺎر ﻣﻲ آﻨﺪ اﻣﺎ ﺷﻤﺎرﻩ ﻓﺎﻳﻞ را در اﺧﺘﻴﺎرﺗـﺎن ﻗـﺮار ﻧﻤـﻲ دهـﺪ ﺗـﺎ‬ ‫ﺑﺘﻮاﻧﻴﺪ اﻋﻤﺎل ﺧﻮاﻧﺪن ﻳﺎ ﻧﻮﺷﺘﻦ را ﺑﺮ روي ﻓﺎﻳﻞ اﻧﺠﺎم دهﻴﺪ‪.‬در اﻳﻨﺼﻮرت در ﺻﻮرت ﻓﺮاﺧﻮاﻧﻲ ﻣﺠﺪد اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻋﺪدي ﻣﺸﺎﺑﻪ‬ ‫ﻓﺮاﺧﻮاﻧﻲ ﻗﺒﻠﻲ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد‪.‫ﺑﺎزآﺮدن ﻓﺎﻳﻞ‪ :‬در اﻳﻦ ﻣﺮﺣﻠﻪ‪ ،‬ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﻣﻴـﺰان ﻣﻌﻴﻨـﻲ از ﺣﺎﻓﻈـﻪ را ﺑـﺮاي ﻧﮕﻬـﺪاري دادﻩ‬ ‫هﺎي ﻓﺎﻳﻞ آﻨﺎر ﻣﻲ ﮔﺬارد‪ .‬‬ ‫ﭘﺲ دﺳﺘﻮرات ﻓﻮق را ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺻﻼح ﻣﻲ آﻨﻴﻢ‪:‬‬ ‫)(‪fNum1 =FreeFile‬‬ ‫)‪FileOpen(fNum1.

‬‬ ‫ﺳﻪ ﻣﻘﺪار اول ﺑﺎ ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒـﻲ‪ ،‬ﻣﻘـﺪار ‪ Random‬ﺑـﺎ ﻓﺎﻳـﻞ هـﺎي ﺑـﺎ دﺳﺘﺮﺳـﻲ ﺗـﺼﺎدﻓﻲ و‬ ‫ﻣﻘﺪار ‪ Binary‬ﺑﺮاي ﻓﺎﻳﻞ هﺎي ﺑﺎﻳﻨﺮي ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‪.‬ﻳﻌﻨﻲ ﻓﻘﻂ ﻣﻲ ﺗﻮان در ﻓﺎﻳﻞ ﻧﻮﺷﺖ‪.‬ﻣﺜﻼ ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ ﻣﻲ ﺗﻮاﻧﻨﺪ ﺑﺮاي ﻓﻘﻂ ﺧﻮاﻧـﺪن ﻳـﺎ ﻓﻘـﻂ ﻧﻮﺷـﺘﻦ‬ ‫ﺑﺎز ﺷﻮﻧﺪ ﻧﻪ هﺮ دو‪ .‬‬ ‫اﻳﻦ ﻣﻘﺪار‪ ،‬ﻳﻚ ﻓﺎﻳﻞ را ﺑﻪ ﻃﻮر ﺗﺼﺎدﻓﻲ ﺑﺎز ﻣـﻲ آﻨـﺪ‪ .‬‬ ‫ﺗﺎﺑﻊ )(‪ FileOpen‬ﺑﺎ درﻳﺎﻓﺖ ﻣﻘﺎدﻳﺮي اﻳﻦ آﺎر را ﺑﺮاي ﺷﻤﺎ اﻧﺠﺎم ﻣﻲ دهﺪ‪.‬اﮔﺮ ﻓﺎﻳﻠﻲ آﻪ ﺑﺎ ﻣﺪ ‪ Output‬ﺑـﺎز ﻣـﻲ ﺷـﻮد وﺟـﻮد ﻧﺪاﺷـﺘﻪ ﺑﺎﺷـﺪ‪ ،‬ﺁن را‬ ‫اﻳﺠﺎد ﻣﻲ آﻨﺪ وﻟﻲ اﮔﺮ وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﺪ‪ ،‬اﻃﻼﻋﺎت ﻗﺒﻠﻲ ﺁن را از ﺑـﻴﻦ ﻣـﻲ ﺑـﺮد‬ ‫و ﺁن را ﺑﺮاي درﻳﺎﻓﺖ اﻃﻼﻋﺎت ﺟﺪﻳﺪ ﺁﻣﺎدﻩ ﻣﻲ آﻨﺪ‪ .0‬ﺷـﺪﻩ اﺳـﺖ‪ .‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ path‬ﻣﺴﻴﺮ و ﻧﺎم ﻓﺎﻳﻠﻲ اﺳﺖ آﻪ ﺑﺎﻳﺪ ﺑﺎز ﺷﻮد و ﺁرﮔﻮﻣﺎن ‪ number‬ﺷـﻤﺎرﻩ اي اﺳـﺖ‬ ‫آﻪ ﺷﻤﺎ ﺑﻪ اﻳﻦ ﻓﺎﻳﻞ اﺧﺘﺼﺎص ﻣﻲ دهﻴﺪ )ﻣﻌﻤﻮﻻ ﺑﺎ ﺗﺎﺑﻊ )(‪.‬‬ ‫اﻳﻦ ﺁرﮔﻮﻣﺎن ﺑﻴـﺸﺘﺮ ﺑـﺮاي ﺑـﺎﻻ ﺑـﺮدن اﻣﻨﻴـﺖ آـﺎر ﺑـﺎ ﻓﺎﻳـﻞ ﺑـﻪ آـﺎر ﻣـﻲ رود و ﺿـﺮورت ﭼﻨـﺪاﻧﻲ در‬ ‫اﺳﺘﻔﺎدﻩ از ﺁن وﺟﻮد ﻧﺪارد‪ .path.‬‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ access‬ﻧﻮع دﺳﺘﺮﺳﻲ ﺑﻪ ﻓﺎﻳﻞ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ‪ .NET‬‬ ‫‪٤٥‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .(FreeFile‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،mode‬ﻧﻮع ﻋﻤﻠﻴﺎﺗﻲ را آﻪ ﻗﺮار اﺳﺖ ﺑﺮ روي ﻓﺎﻳﻞ اﻧﺠﺎم ﺷـﻮد ﺗﻌﻴـﻴﻦ ﻣـﻲ آﻨـﺪ و ﻣـﻲ‬ ‫ﺗﻮاﻧﺪ ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ زﻳﺮ ﺑﺎﺷﺪ‪:‬‬ ‫ﻣﻘﺪار‬ ‫‪Input‬‬ ‫‪Output‬‬ ‫‪Append‬‬ ‫‪Binary‬‬ ‫‪Random‬‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ Mode‬در ﺗﺎﺑﻊ )(‪FileOpen‬‬ ‫ﻋﻤﻠﻜﺮد‬ ‫اﻳﻦ ﻣﻘﺪار ﺑﺮاي ﺑﺎزآﺮدن ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ آﻪ وﺟﻮد دارد ﺑﻪ آﺎر ﻣﻲ رود‪ .‬ﺗﻮﺟـﻪ داﺷـﺘﻪ ﺑﺎﺷـﻴﺪ آـﻪ دﺳـﺘﻮر‬ ‫‪ Open‬در ‪ VB.‬ﻳﻌﻨﻲ هﻢ ﻣﻲ ﺗﻮان اﻃﻼﻋـﺎت را‬ ‫از ﻓﺎﻳﻞ ﺧﻮاﻧﺪ و هﻢ در ﻓﺎﻳﻞ ﻧﻮﺷﺖ‪.access ][.‫)] ‪FileOpen(number.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.share ][.‬‬ ‫ﻣﻘﺎدﻳﺮي آﻪ اﻳﻦ ﺁرﮔﻮﻣﺎن ﻣﻲ ﺗﻮاﻧﺪ ﺑﭙﺬﻳﺮد در ﺟﺪول زﻳﺮ ﺁﻣﺪﻩ اﺳﺖ‪:‬‬ ‫ﻣﻘﺪار‬ ‫‪Read‬‬ ‫‪Write‬‬ ‫‪ReadWrite‬‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ access‬در ﺗﺎﺑﻊ )(‪FileOpen‬‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻓﺎﻳﻞ را در ﺣﺎﻟﺖ ورودي ﺑﺎز ﻣﻲ آﻨﺪ‪ .6.recordLen‬‬ ‫ﺑﺮاي اﺳﺘﻔﺎدﻩ از ﻳﻚ ﻓﺎﻳﻞ‪ ،‬ﺑﺎﻳﺪ اﺑﺘﺪا ﺁن را ﺑﺎز ﻳﺎ در ﺻﻮرت ﻧﻴﺎز ﺁن را اﻳﺠﺎد آﻨﻴﺪ‪.‬ﻳﻌﻨﻲ ﻓﻘﻂ ﻣﻲ ﺗﻮان ﻓﺎﻳﻞ را ﺧﻮاﻧﺪ‪.‬‬ ‫اﻳــﻦ ﻣﻘــﺪار‪ ،‬ﻓﺎﻳــﻞ ﺗﺮﺗﻴﺒــﻲ را ﻃــﻮري ﺑــﺎز ﻣــﻲ آﻨــﺪ آــﻪ ﺑﺘــﻮان اﻃﻼﻋــﺎﺗﻲ را در ﺁن‬ ‫ﻧﻮﺷﺖ‪ .‬در ﺣﺎﻟﺖ ﺑﺎﻳﻨﺮي ﻣﻲ ﺗﻮان ﺑﻪ هـﺮ‬ ‫ﻳﻚ از ﺑﺎﻳﺖ هﺎي ﻓﺎﻳﻞ دﺳﺘﺮﺳﻲ داﺷﺖ و ﻣﻲ ﺗﻮان ﻳﻚ ﺑﺎﻳﺖ را از ﻓﺎﻳـﻞ ﺧﻮاﻧـﺪ ﻳـﺎ‬ ‫در ﻓﺎﻳﻞ ﻧﻮﺷﺖ‪.‬ﭼﻨﺎﻧﭽـﻪ ﻓـﺎﻳﻠﻲ آـﻪ‬ ‫ﻗﺒﻼ ﺑﺮ روي دﻳﺴﻚ وﺟـﻮد ﻧﺪاﺷـﺘﻪ و ﺑﺨـﻮاهﻴﻢ ﺑـﺎ ﻣـﺪ ‪ Input‬ﺑـﺎز آﻨـﻴﻢ‪ ،‬ﺧﻄـﺎﻳﻲ‬ ‫اﺗﻔﺎق ﻣﻲ اﻓﺘﺪ‪.‬‬ ‫اﻳﻦ ﺗـﺎﺑﻊ‪ ،‬ﺟﺎﻧـﺸﻴﻦ دﺳـﺘﻮر ‪ Open‬در ‪ VB.‬‬ ‫ﻓﺎﻳﻞ را در ﺣﺎﻟﺖ ورودي‪-‬ﺧﺮوﺟﻲ ﺑﺎز ﻣﻲ آﻨﺪ‪ .‬ﺑﻪ ﻃﻮر آﻠﻲ اﻳـﻦ ﻣﻘـﺪار ﻓﺎﻳـﻞ‬ ‫را در ﺣﺎﻟﺖ ﺧﺮوﺟﻲ ﺑﺎز ﻣﻲ آﻨﺪ ﻳﻌﻨﻲ ﻓﻘﻂ ﻣﻲ ﺗﻮان اﻃﻼﻋﺎت را ﺑـﻪ ﻓﺎﻳـﻞ اﺿـﺎﻓﻪ‬ ‫آﺮد‪.‬ﭼﻨﺎﻧﭽﻪ ﻓﺎﻳﻞ ﻗﺒﻼ وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷـﺪ‪ ،‬ﺁن‬ ‫را اﻳﺠﺎد ﻣﻲ آﻨﺪ‪.‬ﻳﻌﻨﻲ ﻓﺎﻳﻞ ﺑﺮاي ﺧﻮاﻧـﺪن ﻳـﺎ‬ ‫ﻧﻮﺷﺘﻦ ﻳﺎ هﺮ دو ﻋﻤﻞ ﺑﺎز ﺷﻮد‪.‬اﮔﺮ ﻓﺎﻳـﻞ را ﺑـﺎ‬ ‫اﻳﻦ ﻣﻘﺪار ﺑﺎز آﻨﻴﻢ ﻓﻘﻂ ﻣﻲ ﺗﻮاﻧﻴﻢ اﻃﻼﻋﺎت را از ﺁن ﺑﺨﻮاﻧﻴﻢ‪ .‬‬ ‫ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ آﻪ ﻗﺒﻼ وﺟـﻮد داﺷـﺘﻪ ﺑﺎﺷـﺪ و ﺑﺨـﻮاهﻴﻢ اﻃﻼﻋـﺎﺗﻲ زا ﺑـﻪ ﺁن اﺿـﺎﻓﻪ‬ ‫آﻨﻴﻢ‪ ،‬ﺑﺎﻳﺪ از اﻳﻦ ﻣﻘﺪار اﺳﺘﻔﺎدﻩ آﻨﻴﻢ‪ .NET‬ﻗﺎﺑﻞ اﺳﺘﻔﺎدﻩ ﻧﻴﺴﺖ‪.mode [.‬در اﻳـﻦ ﺣﺎﻟـﺖ ﻣـﻲ ﺗـﻮان در‬ ‫ﻓﺎﻳﻞ ﻧﻮﺷﺖ ﻳﺎ از ﻓﺎﻳﻞ ﺧﻮاﻧﺪ‪.‬‬ ‫اﻳﻦ ﻣﻘﺪار‪ ،‬ﻓﺎﻳﻞ را ﺑﻪ ﺻﻮرت ﺑﺎﻳﻨﺮي ﺑﺎز ﻣﻲ آﻨﺪ‪ .‬ﭘﺲ اﺳﺘﻔﺎدﻩ از ﺁرﮔﻮﻣﺎن ‪ ReadWrite‬اﻳﻦ ﺁرﮔﻮﻣـﺎن در هﻨﮕـﺎم ﺑـﺎز آـﺮدن ﻳـﻚ‬ ‫ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ ﺑﻲ اﺛﺮ اﺳﺖ‪.‬‬ ‫ﻓﺎﻳﻞ را در ﺧﺎﻟﺖ ﺧﺮوﺟﻲ ﺑﺎز ﻣﻲ آﻨﺪ‪ .

‬‬ ‫ﺑﺮﻧﺎﻣﻪ هﺎي دﻳﮕﺮ ﻓﻘﻂ در ﺻﻮرﺗﻲ ﻣﺠﺎز ﺑﻪ اﺳﺘﻔﺎدﻩ از ﻓﺎﻳﻞ هـﺴﺘﻨﺪ آـﻪ‬ ‫ﺁن را ﻓﻘﻂ ﺑﺮاي ﻧﻮﺷﺘﻦ ﺑﺎز آﺮدﻩ ﺑﺎﺷﻨﺪ‪.‬‬ ‫ﻃــﻮل رآــﻮرد‪ ،‬ﻣﺠﻤــﻮع ﺑﺎﻳــﺖ هــﺎي ﺗﻤــﺎﻣﻲ ﻓﻴﻠــﺪهﺎي ﺁن ﻓﺎﻳــﻞ اﺳــﺖ آــﻪ ﻣــﻲ ﺗﻮاﻧﻴــﺪ ﺑــﺎ دﺳــﺘﻮر‬ ‫)‪ Len(record‬ﺁن را ﻣﺤﺎﺳﺒﻪ آﻨﻴﺪ‪.‬‬ ‫ﺑﺮﻧﺎﻣﻪ هﺎي دﻳﮕﺮ ﻓﻘﻂ در ﺻﻮرﺗﻲ ﻣﺠﺎز ﺑﻪ اﺳﺘﻔﺎدﻩ از ﻓﺎﻳﻞ هـﺴﺘﻨﺪ آـﻪ‬ ‫ﺁن را ﻓﻘﻂ ﺑﺮاي ﺧﻮاﻧﺪن ﺑﺎز آﺮدﻩ ﺑﺎﺷﻨﺪ‪.‬‬ ‫هﻨﮕﺎﻣﻲ آﻪ در وﻳﮋوال ﺑﻴﺴﻴﻚ ﻓﺎﻳﻠﻲ ﺑﺎ دﺳﺘﺮﺳـﻲ ﺗـﺼﺎدﻓﻲ اﻳﺠـﺎد ﻣـﻲ آﻨﻴـﺪ‪ ،‬هـﻴﭻ اﻃﻼﻋـﺎﺗﻲ‬ ‫راﺟﻊ ﺑﻪ ﻃﻮل رآﻮرد ﻳﺎ ﺳﺎﺧﺘﺎر ﺁن در ﻓﺎﻳﻞ ذﺧﻴﺮﻩ ﻧﻤﻲ ﺷﻮد‪.‬‬ ‫دﺳﺘﻮر زﻳﺮ‪ ،‬ﻓﺎﻳﻠﻲ را آﻪ ﺷﻤﺎرﻩ ي ﺁن در ﻋﺒﺎرت ‪ fNum1‬وﺟﻮد دارد ﻣﻲ ﺑﻨﺪد‪.dat ”.‬‬ ‫و اﻣﺎ ﺁﺧﺮﻳﻦ ﺁرﮔﻮﻣﺎن ﻳﻌﻨﻲ ﺁرﮔﻮﻣﺎن اﺧﺘﻴـﺎري ‪ recordlen‬آـﻪ ﻓﻘـﻂ در ﻓﺎﻳـﻞ هـﺎي ﺑـﺎ دﺳﺘﺮﺳـﻲ‬ ‫ﺗﺼﺎدﻓﻲ آﺎرﺑﺮد دارد‪.‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﻤﺎﻣﻲ ﻓﺎﻳﻞ هﺎﻳﻲ را آﻪ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ FileOpen‬در ﺑﺮﻧﺎﻣـﻪ ﺷـﻤﺎ ﺑـﺎز ﺷـﺪﻩ اﻧـﺪ‬ ‫ﻣﻲ ﺑﻨﺪد‪. OpenAccess.‬‬ ‫ﺑﺮﻧﺎﻣﻪ هﺎي دﻳﮕﺮ ﻣﺠﺎز ﺑﻪ اﺳﺘﻔﺎدﻩ از ﻓﺎﻳﻞ ﻧﻴﺴﺘﻨﺪ‬ ‫ﺁرﮔﻮﻣﺎن ‪ share‬ﻳﻚ ﭘﺎراﻣﺘﺮ ﺑﺴﻴﺎر ﻣﻬﻢ ﺑﺮاي ﺑﺮﻧﺎﻣﻪ هـﺎﻳﻲ اﺳـﺖ آـﻪ ﺗﺤـﺖ ﺷـﺒﻜﻪ ﻧﻮﺷـﺘﻪ ﻣـﻲ‬ ‫ﺷﻮﻧﺪ‪ .‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ record‬در اﻳﻦ دﺳﺘﻮر ﻧﺎم ﺳﺎﺧﺘﺎري اﺳﺖ آﻪ ﺑﺮاي ﺑﺎزآﺮدن ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ ﺑـﻪ آـﺎر ﺑـﺮدﻩ‬ ‫اﻳﺪ‪. OpenMode.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ share‬ﻣﻲ ﺗﻮاﻧﺪ ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ زﻳﺮ را ﺑﭙﺬﻳﺮد‪:‬‬ ‫ﻣﻘﺪار‬ ‫‪Shared‬‬ ‫‪LockRead‬‬ ‫‪LockWrite‬‬ ‫‪LockReadWrite‬‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ share‬در ﺗﺎﺑﻊ )(‪FileOpen‬‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﺑﺮﻧﺎﻣﻪ هﺎي دﻳﮕﺮ ﻣﻲ ﺗﻮاﻧﻨﺪ از ﻓﺎﻳﻞ اﺳﺘﻔﺎدﻩ آﻨﻨﺪ‪.NET‬‬ ‫‪٤٦‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل دو آﺎرﺑﺮ ﺑﻪ ﻃﻮر هﻤﺰﻣﺎن ﻗﺼﺪ ﻧﻮﺷﺘﻦ در ﻳﻚ ﻓﺎﻳﻞ را دارﻧﺪ‪.‬‬ ‫اﻳﻦ ﻣﻮرد را ﻗﺒﻞ از ﺑﺎزآﺮدن اﻳﻦ ﻧﻮع ﻓﺎﻳﻞ هﺎ ﺑﺎﻳﺪ ﺑﺪاﻧﻴﺪ‪. “c:\samples \vb \cust.‬‬ ‫)‪FileClose(fNum1‬‬ ‫)(‪Reset‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ در ﺣﻘﻴﻘﺖ آﺎر ﺷﻤﺎ را در ﺑﺴﺘﻦ ﻓﺎﻳﻞ هﺎ ﺑﺴﻴﺎر ﺁﺳﺎﻧﺘﺮ ﻣﻲ آﻨﺪ‪.Output.dat‬را آﻪ ﻳـﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ اﺳـﺖ ﺑـﺎ اﺧﺘـﺼﺎص دادن‬ ‫ﻋﺪدي آﻪ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ FreeFile‬ﺑﻪ دﺳﺖ ﺁوردﻩ‪ ،‬در ﺣﺎﻟﺖ ورودي‪-‬ﺧﺮوﺟﻲ ﺑﺎز ﻣﻲ آﻨﺪ‪:‬‬ ‫)(‪Dim Fnum As Integer =FreeFile‬‬ ‫)‪FileOpen(Fnum.ReadWrite‬‬ ‫)‪FileClose(file_number‬‬ ‫ﭘﺲ از اﻳﻨﻜﻪ آﺎر ﺑﺎ ﻓﺎﻳﻞ ﺗﻤﺎم ﺷﺪ‪ ،‬ﺑﺎﻳﺪ ﺁن را ﺑﺴﺖ‪.‫وﻟﻲ ﺟﻬﺖ ﺑﺎﻻ ﺑﺮدن ﺿﺮﻳﺐ اﻣﻨﻴﺖ اﺳﺘﻔﺎدﻩ از ﻓﺎﻳﻞ‪ ،‬هﻨﮕﺎﻣﻲ آﻪ ﻓﺎﻳـﻞ را در هـﺮ ﺣـﺎﻟﺘﻲ ﺑـﺎز ﻣـﻲ‬ ‫آﻨﻴﺪ‪ ،‬ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻧﻮع ﻓﺎﻳﻞ اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺁرﮔﻮﻣﺎن ﻧﻴﺰ ﺿﺮري ﻧﺪارد‪.‬‬ ‫دﺳﺘﻮر زﻳﺮ ﻓﺎﻳﻞ ‪ C:\samples\vb\cust.‬‬ ‫ﺑﻪ ﻋﺒﺎرت دﻳﮕﺮ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻧﺤﻮﻩ دﺳﺘﺮﺳﻲ ﺑﺮﻧﺎﻣﻪ هﺎي دﻳﮕﺮ را ﺑﻪ ﻓﺎﻳﻠﻲ آﻪ ﺷﻤﺎ ﺑـﺎز آـﺮدﻩ‬ ‫و در ﺣﺎل اﺳﺘﻔﺎدﻩ از ﺁن هﺴﺘﻴﺪ ﺗﻌﻴﻴﻦ آﻨﻴﺪ‪.‬‬ ‫اﮔﺮ ﻓﺎﻳﻠﻲ آﻪ ﻗﺼﺪ ﺑﺎزآﺮدن ﺁن را دارﻳﺪ از اﻳﻦ ﻧﻮع ﺑﺎﺷﺪ ﺑﺎﻳﺪ ﻃﻮل هﺮ رآﻮرد ﻓﺎﻳﻞ را آﻪ ﺑـﺮ ﺣـﺴﺐ‬ ‫ﺑﺎﻳﺖ اﺳﺖ ﺑﻪ وﺳﻴﻠﻪ اﻳﻦ ﺁرﮔﻮﻣﺎن ﻣﺸﺨﺺ آﻨﻴﺪ‪.‬‬ ‫ﺗﺎﺑﻊ )(‪ FileClose‬ﻓﺎﻳﻠﻲ را آـﻪ ﺷـﻤﺎرﻩ ي ﺁن ﺑـﻪ وﺳـﻴﻠﻪ ي ﺁرﮔﻮﻣـﺎن ‪ file_number‬ﻣـﺸﺨﺺ‬ ‫ﺷﺪﻩ ﻣﻲ ﺑﻨﺪد‪.‬‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،share‬ﻧﺤﻮﻩ ﻋﻜﺲ اﻟﻌﻤﻞ ﻓﺎﻳﻠﻲ آﻪ ﺗﻮﺳﻂ ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﺑﺎز ﺷﺪﻩ اﺳـﺖ را ﺑـﻪ‬ ‫ﺑﺮﻧﺎﻣﻪ هﺎي دﻳﮕﺮ وﻳﻨﺪوز‪ ،‬در هﻤﺎن زﻣﺎن آﻪ ﺷﻤﺎ ﻓﺎﻳﻞ را ﺑﺎز آﺮدﻩ اﻳﺪ ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ‪.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.

‬‬ ‫ﺗﺎﺑﻊ )(‪ PrintLine‬هﻤﺎن آﺎري را اﻧﺠﺎم ﻣﻲ دهﺪ آﻪ ﺗﺎﺑﻊ )(‪ Print‬اﻧﺠﺎم ﻣﻲ دهﺪ ﺑـﺎ اﻳـﻦ ﺗﻔـﺎوت‬ ‫آﻪ ﺑﺎ هﺮ ﺑﺎر ﻓﺮاﺧﻮاﻧﻲ‪ ،‬دادﻩ را در ﺧﻄﻮط ﻣﺠﺰا ﻗﺮار ﻣﻲ دهـﺪ هﻤﺎﻧﻨـﺪ دﺳـﺘﻮر ‪ WriteLn‬در زﺑـﺎن‬ ‫ﭘﺎﺳﻜﺎل آﻪ اﻃﻼﻋﺎت را در ﺧﻄﻮط ﺟﺪا‪ ،‬ذﺧﻴﺮﻩ ﻣﻲ آﻨﺪ ﻳﺎ ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪.‬‬ ‫ﺗﺎﺑﻊ )(‪ EOF‬ﺑﺮاي ﺗﺴﺖ ﺷﺮط ﭘﺎﻳﺎن ﻓﺎﻳﻞ ﺑﻪ آـﺎر ﻣـﻲ رود‪ .‬ﻣﺜﻼ‪Tab(12) :‬‬ ‫ﻣﺜﺎل زﻳﺮ ﻳﻚ ﻓﺎﻳﻞ ﻣﺘﻨﻲ را ﺳﺎﺧﺘﻪ و ﻣﻘﺪاري دادﻩ را در ﺁن ذﺧﻴﺮﻩ ﻣﻲ آﻨﺪ‪:‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬اﻳﻦ ﻣﻘﺎدﻳﺮ ﺑﺎ اﺳﺘﻔﺎدﻩ از آﺎراآﺘﺮ )‪ (. "and this is the second half of the same line.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،file_number‬ﺷﻤﺎرﻩ ﻓﺎﻳﻠﻲ اﺳﺖ آﻪ ﻗﺒﻼ ﺑﺎ ﻳﻜﻲ از دو ﺣﺎﻟﺖ ﺑـﺎﻻ ﺑـﺎز ﺷـﺪﻩ اﺳـﺖ و‬ ‫ﺁرﮔﻮﻣﺎن ‪ output_list‬ﻧﻴﺰ ﻳﻚ ﺁراﻳﻪ ي ﭘـﺎراﻣﺘﺮي اﺳـﺖ‪ ،‬ﻳﻌﻨـﻲ ﻣﻘـﺎدﻳﺮ ﻳـﺎ ﻣﺘﻐﻴﺮهـﺎي ﻣﻘـﺪاردهﻲ‬ ‫ﺷﺪﻩ اي آﻪ ﺑﺎﻳﺪ در ﻓﺎﻳﻞ ﻧﻮﺷﺘﻪ ﺷﻮﻧﺪ‪.‬‬ ‫ﻧﻜﺘــﻪ‪ :‬ﻣﻨﻈــﻮر از ﺁراﻳــﻪ ي ﭘــﺎراﻣﺘﺮي در ‪ ،VB‬ﺁرﮔﻮﻣــﺎﻧﻲ اﺳــﺖ آــﻪ ﻣــﻲ ﺗﻮاﻧــﺪ ﻣﻘــﺎدﻳﺮ ﻧﺎﻣﺤــﺪودي‬ ‫ﺑﭙﺬﻳﺮد‪ .‫)‪EOF(file_number) .‬دﺳﺘﻮر زﻳﺮ اﻳﻦ آﺎر را ﺑﺮاي ﻣﺎ اﻧﺠﺎم ﻣﻲ دهﺪ‪:‬‬ ‫)‪Rec_Length =LOF(file_number) / Len(record‬‬ ‫)‪Print (file_number.output_list) .‬‬ ‫ﺑﺮاي ﺧﻮاﻧﺪن دادﻩ هﺎﻳﻲ آﻪ ﺑﺎ ﺗﺎﺑﻊ )(‪ Print‬در ﻓﺎﻳـﻞ ذﺧﻴـﺮﻩ ﺷـﺪﻩ اﻧـﺪ از ﺗﻮاﺑـﻊ )(‪ LineInput‬و‬ ‫)(‪ Input‬اﺳﺘﻔﺎدﻩ ﻣﻲ آﻨﻴﻢ‪. PrintLine(file_number. var1.‬‬ ‫هﻤﭽﻨﻴﻦ ﺧﻮد ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺮاي اﻳﻦ ﻓﺎﺻﻠﻪ ﻣﻘﺪاري ﺗﻌﻴﻴﻦ آﻨﻴﺪ‪ .‬‬ ‫ﺷﺒﻪ آﺪ زﻳﺮ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ EOF‬و ﻳﻚ ﺣﻠﻘﻪ ﺗﻜﺮار‪ ،‬ﭘﺎﻳﺎن ﻳﻚ ﻓﺎﻳﻞ را ﭼﻚ ﻣﻲ آﻨﺪ‪:‬‬ ‫}رﻓﺘﻦ ﺑﻪ اوﻟﻴﻦ رآﻮرد ﻓﺎﻳﻞ{‬ ‫)‪While Not EOF(fNum‬‬ ‫}ﭘﺮدازش رآﻮرد ﺟﺎري{‬ ‫}رﻓﺘﻦ ﺑﻪ رآﻮرد ﺑﻌﺪ{‬ ‫‪End While‬‬ ‫ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ LOF‬ﻗﺎدر ﺑﻪ ﻣﺤﺎﺳﺒﻪ ي ﺗﻌﺪاد رآﻮرد هﺎي ﻳﻚ ﻓﺎﻳﻞ ﺑﺎ دﺳﺘﺮﺳـﻲ ﺗـﺼﺎدﻓﻲ‬ ‫هﺴﺘﻴﺪ‪ .‬اﻳـﻦ ﺗـﺎﺑﻊ ﻓـﺎﻳﻠﻲ را آـﻪ ﺷـﻤﺎرﻩ ﺁن ﺑـﻪ‬ ‫وﺳﻴﻠﻪ ﺁرﮔﻮﻣﺎن ‪ file_number‬ﻣﺸﺨﺺ ﺷﺪﻩ ﭼﻚ ﻣﻲ آﻨﺪ و ﭼﻨﺎﻧﭽﻪ اﺷﺎرﻩ ﮔﺮ ﻓﺎﻳﻞ ﺑﻪ اﻧﺘﻬـﺎي‬ ‫ﺁن رﺳﻴﺪﻩ ﺑﺎﺷﺪ‪ ،‬اﻳﻦ ﺗﺎﺑﻊ ﻣﻘﺪار ‪ True‬وﮔﺮﻧﻪ ﻣﻘﺪار ‪ False‬را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪. “My VB World”.333‬‬ ‫اﻳﻦ دﺳﺘﻮر‪ ٤ ،‬ﻣﻘﺪار ﺷﺎﻣﻞ ﻣﻘﺪار ‪ ٢‬ﻣﺘﻐﻴﺮ‪ ،‬ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي و ﻳـﻚ ﻣﻘـﺪار ﻋـﺪدي را در ﻓـﺎﻳﻠﻲ‬ ‫آﻪ ﺷﻤﺎرﻩ ﺁن در ﻋﺒﺎرت ‪ fNum‬وﺟﻮد دارد ذﺧﻴﺮﻩ ﻣﻲ آﻨﺪ‪.output_list‬‬ ‫ﺑﺮاي ﻧﻮﺷﺘﻦ در ﻳﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ آـﻪ ﺑـﻪ ﺻـﻮرت ‪ Output‬ﻳـﺎ ‪ Append‬ﺑـﺎز ﺷـﺪﻩ اﺳـﺖ از ﺗـﺎﺑﻊ‬ ‫)(‪ Print‬اﺳﺘﻔﺎدﻩ ﻣﻲ آﻨﻴﻢ‪.333. LOF(file_number‬‬ ‫اﻳﻦ دو ﺗﺎﺑﻊ ﻣﻌﻤﻮﻻ در ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ ﻓﺎﻳﻞ هﺎ ﺳﺮ و آﺎر دارﻧﺪ ﺑﺴﻴﺎر ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‪.‬‬ ‫دﺳﺘﻮر زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫)‪Print(fNum.‬‬ ‫ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ ﻓﻴﻠﺪهﺎﻳﻲ آﻪ در هﺮ ﺧﻂ ﻓﺎﻳﻞ ﻣﺘﻨﻲ ذﺧﻴﺮﻩ ﻣـﻲ ﺷـﻮﻧﺪ ﻣـﻲ ﺗﻮاﻧﻴـﺪ از آﻠﻤـﻪ‬ ‫آﻠﻴﺪي )‪ (Tab‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ ﺗﺎ ‪ VB‬در هﻨﮕﺎم ذﺧﻴـﺮﻩ دادﻩ هـﺎ در ﻓﺎﻳـﻞ‪ ،‬ﺑـﻴﻦ ﻓﻴﻠـﺪ هـﺎي ﻣﺨﺘﻠـﻒ‬ ‫ﻓﺎﺻﻠﻪ ﻗﺮار دهﺪ‪.‬‬ ‫ﺗﺎﺑﻊ )(‪ Print‬دادﻩ هﺎ را در ﺧﻄـﻮط ﻣﺠـﺰا ذﺧﻴـﺮﻩ ﻧﻤـﻲ آﻨـﺪ ﻳﻌﻨـﻲ اﻳﻨﻄـﻮر ﻧﻴـﺴﺖ آـﻪ ﺑـﺎ هـﺮ ﺑـﺎر‬ ‫ﻓﺮاﺧﻮاﻧﻲ اﻳﻦ ﺗﺎﺑﻊ‪ ،‬دادﻩ هﺎ در ﺧﻂ ﺑﻌﺪي ﻓﺎﻳﻞ ذﺧﻴﺮﻩ ﺷﻮﻧﺪ ﺑﻠﻜﻪ ﭘﺸﺖ ﺳﺮ هـﻢ و ﺑـﺪون ﻓﺎﺻـﻠﻪ‬ ‫ﻗﺮار ﺧﻮاهﻨﺪ ﮔﺮﻓﺖ‪.‬‬ ‫ﺗﺎﺑﻊ )(‪ Print‬ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﺑﻴﻦ ﻓﻴﻠﺪهﺎي ﻣﺨﺘﻠﻒ در ﻳﻚ ﻓﺎﻳﻞ ﻓﺎﺻﻠﻪ اي ﻗﺮار ﻧﻤﻲ دهﺪ‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪ ،‬دﺳﺘﻮر زﻳﺮ ﻓﻘﻂ ﻳﻚ ﺧﻂ ﻣﺘﻨﻲ در ﻓﺎﻳﻠﻲ آﻪ ﺷﻤﺎرﻩ ﺁن در ‪ fNum‬وﺟـﻮد دارد ﻣـﻲ‬ ‫ﻧﻮﻳﺴﺪ‪:‬‬ ‫)" ‪Print(fNum.NET‬‬ ‫‪٤٧‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﺗﺎﺑﻊ )(‪ ،LOF‬اﻧﺪازﻩ ﻳﻚ ﻓﺎﻳﻞ ﺑﺎز را آـﻪ ﺷـﻤﺎرﻩ ﺁن ﺑـﻪ وﺳـﻴﻠﻪ ﺁرﮔﻮﻣـﺎن ‪ file_number‬ﻣـﺸﺨﺺ‬ ‫ﺷﺪﻩ اﺳﺖ ﺑﺮ ﺣﺴﺐ ﺑﺎﻳﺖ ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬از هﻢ ﺟﺪا ﻣﻲ ﺷﻮﻧﺪ‪. "This is the first half of the line‬‬ ‫)"‪Print(fNum. var2.

“Rad”. TAB(45). TAB.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ file_number‬ﺷﻤﺎرﻩ ﻓﺎﻳﻠﻲ اﺳـﺖ آـﻪ ﺑـﻪ ﺻـﻮرت ‪ Input‬ﺑـﺎز ﺷـﺪﻩ اﺳـﺖ و ﺁرﮔﻮﻣـﺎن‬ ‫‪ ،var‬ﻳــﻚ ﺁراﻳــﻪ ﭘــﺎراﻣﺘﺮي اﺳــﺖ آــﻪ ﺷــﺎﻣﻞ اﺳــﺎﻣﻲ ﻓﻴﻠــﺪهﺎ ﻳــﺎ ﻟﻴــﺴﺘﻲ از ﻣﺘﻐﻴﺮهــﺎ اﺳــﺖ آــﻪ‬ ‫اﻃﻼﻋﺎت ﺧﻮاﻧﺪﻩ ﺷﺪﻩ در ﺁﻧﻬﺎ ﻗﺮار ﻣﻲ ﮔﻴﺮد‪. 25‬‬ ‫)”*************************“ ‪PrintLine(fNum. TAB.txt‬‬ ‫)(‪Dim fNum As Integer =FreeFile‬‬ ‫)‪FileOpen(fNum. TAB(12).‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬در اوﻟﻴﻦ ﺑﺎر ﻓﺮاﺧﻮاﻧﻲ‪ ،‬اوﻟـﻴﻦ ﺧـﻂ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ را ﺑﺮﮔـﺸﺖ ﻣـﻲ دهـﺪ و در ﻓﺮاﺧـﻮاﻧﻲ‬ ‫ﺑﻌﺪي دوﻣﻴﻦ ﺧﻂ و ﺑﻪ هﻤﻴﻦ ﻣﻨﻮال‪. TAB(25). “Administrator”.‬‬ ‫ﺗﺎﺑﻊ )(‪ Input‬دادﻩ هﺎي ﻳﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ را ﺧﻮاﻧـﺪﻩ و ﺁﻧﻬـﺎ را در ﻣﺘﻐﻴـﺮي آـﻪ ﺑـﻪ ﻋﻨـﻮان دوﻣـﻴﻦ‬ ‫ﺁرﮔﻮﻣﺎن اﻳﻦ ﺗﺎﺑﻊ وﺟﻮد دارد ﻳﻌﻨﻲ ‪ var‬ﻣﻲ رﻳﺰد‪. “arvin”. TAB.NET‬‬ ‫‪٤٨‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ . “amiri”. TAB. “sanaei”.Output‬‬ ‫)‪PrintLine(fNum. TAB. TAB. 28‬‬ ‫)‪PrintLine(fNum. “sina”. TAB(25).numVal‬‬ ‫)‪Input(1.var‬‬ ‫ﺑﺪﻳﻬﻲ اﺳﺖ آﻪ ﭘﺲ از ﻧﻮﺷﺘﻦ در ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒـﻲ‪ ،‬ﺑﺎﻳـﺪ ﺑﺘـﻮان اﻃﻼﻋـﺎت را از ﺁن ﺧﻮاﻧـﺪ و ﭘـﺮدازش‬ ‫آﺮد‪ . TAB. “ahmadi”. “amiri”.‫‪On Error Resume Next‬‬ ‫)” ‪Kill(“c:\test. 28‬‬ ‫)‪PrintLine(fNum. “sanaei”.‬وﻟﻲ ﭼﻨﺎﻧﭽﻪ ﺗﻌﺪاد ﻓﻴﻠﺪهﺎﻳﻲ آﻪ ﻧﺎم ﺁﻧﻬﺎ در ﺁرﮔﻮﻣﺎن ‪ var‬ﻣﻲ ﻧﻮﻳـﺴﻴﺪ‪،‬‬ ‫ﺑﻴﺸﺘﺮ از ﺗﻌﺪاد ﻓﻴﻠﺪهﺎي ﻳﻚ رآﻮرد ﻓﺎﻳﻞ ﺑﺎﺷﺪ‪ ،‬ﺑـﻪ ﺗﻌـﺪاد ﻻزم از رآﻮردهـﺎي ﺑﻌـﺪي ﺧﻮاﻧـﺪﻩ ﻣـﻲ‬ ‫ﺷﻮﻧﺪ‪.‬‬ ‫)‪PrintLine(fNum. “sina”. 33‬‬ ‫)‪PrintLine(fNum. TAB(12).DateVal As Date‬‬ ‫)‪Input(1. TAB(25). “arvin”. “Behrouz”. TAB. TAB. “ahmadi”. TAB.txt”.‬ﺑﺮاي ﺧﻮاﻧﺪن اﻃﻼﻋﺎت از ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ‪ ،‬ﺑﺎﻳﺪ ﺁن را ﺑﻪ ﺻﻮرت ‪ Input‬ﺑﺎز آﺮد‪. “Rad”. TAB(12).‬‬ ‫در اﻳﻦ دﺳﺘﻮر‪ ،‬اﮔﺮ هﻨﮕﺎم ﺧﻮاﻧﺪن ﻓﺎﻳﻞ ﺗﻌﺪاد ﻓﻴﻠﺪهﺎﻳﻲ آﻪ ﺷﻤﺎ ﻧﺎم ﺁﻧﻬﺎ را در ﺁرﮔﻮﻣﺎن ‪ var‬ﻣـﻲ‬ ‫ﺁورﻳﺪ از ﺗﻌﺪاد ﻓﻴﻠﺪهﺎي ﻓﺎﻳﻞ آﻤﺘﺮ ﺑﺎﺷﺪ‪ ،‬ﻓﻴﻠـﺪهﺎي ﺑﻌـﺪي در ﻓﺮاﺧـﻮاﻧﻲ ﺑﻌـﺪي ﻓﺮﻣـﺎن )(‪Input‬‬ ‫ﻧﻤﺎﻳﺶ دادﻩ ﻣﻲ ﺷﻮﻧﺪ‪ . “Manager”. “Manager”.DateVal‬‬ ‫)‪LineInput(file_number‬‬ ‫ﭘﻴﺸﻨﻬﺎد ﻣﻲ آﻨﻢ ﺑﺮاي ﺧﻮاﻧﺪن ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ از اﻳﻦ ﺗﺎﺑﻊ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ file_number‬ﺷﻤﺎرﻩ ﻓﺎﻳـﻞ ﺑـﺎز ﺷـﺪﻩ اﺳـﺖ و اﻳـﻦ ﺗـﺎﺑﻊ ﻳـﻚ ﺳـﻄﺮ از ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ را‬ ‫ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪. “pedram”. TAB(45).‬‬ ‫)‪Line1 =LineInput(fNum‬‬ ‫)‪Line2 =LineInput(fNum‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic. “Programmer”. 3‬‬ ‫)‪PrintLine(fNum. “Programmer”. TAB. 25‬‬ ‫)‪FileClose(fNum‬‬ ‫ﺧﺮوﺟﻲ دﺳﺘﻮرات ﺑﺎﻻ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺧﻮاهﺪ ﺷﺪ‪:‬‬ ‫‪33‬‬ ‫‪28‬‬ ‫‪41‬‬ ‫‪25‬‬ ‫‪33‬‬ ‫‪28‬‬ ‫‪41‬‬ ‫‪25‬‬ ‫‪Behrouz‬‬ ‫‪Rad‬‬ ‫‪Manager‬‬ ‫‪sina‬‬ ‫‪ahmadi‬‬ ‫‪Programmer‬‬ ‫‪arvin‬‬ ‫‪sanaei‬‬ ‫‪Engineer‬‬ ‫‪pedram‬‬ ‫‪amiri‬‬ ‫‪Administrator‬‬ ‫*************************‬ ‫‪Behrouz‬‬ ‫‪Rad‬‬ ‫‪Manager‬‬ ‫‪sina‬‬ ‫‪ahmadi‬‬ ‫‪Programmer‬‬ ‫‪arvin‬‬ ‫‪sanaei‬‬ ‫‪Engineer‬‬ ‫‪pedram‬‬ ‫‪amiri‬‬ ‫‪Administrator‬‬ ‫)‪Input(file_number. 41‬‬ ‫)‪PrintLine(fNum. “Engineer” .‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪ ،‬دﺳﺘﻮرات زﻳﺮ ﻳﻚ ﻣﻘﺪار ﻋﺪدي و ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ را از ﻓـﺎﻳﻠﻲ آـﻪ ﺑـﺎز ﺷـﺪﻩ‬ ‫اﺳﺖ ﻣﻲ ﺧﻮاﻧﻨﺪ‪:‬‬ ‫‪Dim numVal As Long. TAB. “pedram”. TAB(25). “c:\test. TAB(12). TAB(45). “Engineer”. 41‬‬ ‫)‪PrintLine(fNum. TAB(45). “Behrouz”. OpenMode.‬‬ ‫دﺳﺘﻮرات زﻳﺮ ﺳﻄﺮهﺎي اول و دوم ﻳﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ را در ﻣﺘﻐﻴﺮهـﺎي ‪ Line1‬و ‪ Line2‬ﻗـﺮار ﻣـﻲ‬ ‫دهﻨﺪ‪. “Administrator”.

“C:\products.‬هﺮ ﻣﺸﺨﺼﻪ از اﻳﻦ ﻣﺤﺼﻮل در ﻳﻚ ﻣﺘﻐﻴﺰ ﺑﻪ ﻧﺎم ‪ ProductRecord‬ﻗﺮار ﺧﻮاهـﺪ‬ ‫ﮔﺮﻓﺖ‪ .‬ﺳﺎﺧﺘﺎر ‪ ProductRecord‬را ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺗﻌﺮﻳﻒ ﻣﻲ آﻨﻢ‪:‬‬ ‫ﺗﻮﺟﻪ‪ :‬در ‪ VB.‬‬ ‫ﺗﺎﺑﻊ )(‪ FilePut‬ﺑﺮاي ﻧﻮﺷﺘﻦ رآﻮرد و ﺗﺎﺑﻊ )(‪ FileGet‬ﺑﺮاي ﺧﻮاﻧﺪن رآﻮرد اﺳﺘﻔﺎدﻩ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬ ‫‪Structure ProductRecord‬‬ ‫‪ProductID As String‬‬ ‫‪Description As String‬‬ ‫‪Price As Decimal‬‬ ‫‪End Type‬‬ ‫اﻃﻼﻋﺎت آﺎﻻ ﻗﺒﻞ از ذﺧﻴﺮﻩ ﺷﺪن در ﻓﺎﻳﻞ‪ ،‬در هﺮ ﻳﻚ از اﻳﻦ ‪ ٣‬ﻣﺘﻐﻴﺮ ﻗﺮار ﺧﻮاهﻨﺪ ﮔﺮﻓﺖ‪.6.‬‬ ‫‪FilePut(file_number.Price = 799.ProductID = “TV00180-A‬‬ ‫” ‪PRec.‬‬ ‫)] ‪FileGet(file_number.dat ”.‫ﺑﺮاي ذﺧﻴﺮﻩ ﺳﺎزي ﻣﺘﻦ هﺎي ﺳﺎدﻩ در ﻳﻚ ﻓﺎﻳﻞ‪ ،‬ﻳﻚ ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ درﺳﺖ آﻨﻴـﺪ و دادﻩ هـﺎي ﺧـﻮد‬ ‫را در ﺁن ذﺧﻴﺮﻩ آﺮدﻩ و در ﻣﻮﻗﻊ ﻟﺰوم ﺑﺮاي ﺧﻮاﻧﺪن ﺧﻂ ﺑﻪ ﺧﻂ دادﻩ هﺎي ذﺧﻴﺮﻩ ﺷﺪﻩ ﺑـﺎ اﺳـﺘﻔﺎدﻩ‬ ‫از ﺗﺎﺑﻊ )(‪ LineInput‬ﻳﺎ ﺑﺮاي ﺧﻮاﻧﺪن آﻞ ﻓﺎﻳﻞ از ﺗﺎﺑﻊ )(‪ FileGet‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.Random‬‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﻣﻦ در ﺗﺎﺑﻊ )(‪ FileOpen‬از ذآﺮ ﻣﺘﻐﻴﺮ ﺁﺧﺮ آﻪ ﻃـﻮل رآـﻮرد را ﺗﻌﻴـﻴﻦ ﻣـﻲ‬ ‫آﻨﺪ ﺧﻮدداري آﺮدم‪ .‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ record_number‬ﻳﻚ ﭘﺎراﻣﺘﺮ اﺧﺘﻴﺎري اﺳﺖ و ﭼﻨﺎﻧﭽﻪ از ذآﺮ ﺁن ﺧﻮدداري ﺷﻮد‪ ،‬رآـﻮرد‬ ‫در ﻣﻜﺎن ﻓﻌﻠﻲ اﺷﺎرﻩ ﮔﺮ ﻓﺎﻳﻞ ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮد‪) .‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔﺮ ﺗﺎﺑﻊ )(‪ ١٠ ،FilePut‬ﺑﺎر ﭘـﺸﺖ ﺳـﺮ هـﻢ و ﺑـﺪون ﺗﻌﻴـﻴﻦ آـﺮدن ﺷـﻤﺎرﻩ رآـﻮرد‬ ‫ﻓﺮاﺧﻮاﻧﻲ ﺷﻮد‪ ١٠ ،‬رآﻮرد اول ﻓﺎﻳﻞ ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ‪ ،‬اﻳﺠﺎد ﻳﺎ ﺑﺎزﻧﻮﻳﺴﻲ ﻣﻲ ﺷﻮد‪.‬‬ ‫ﭘﺲ از اﻳﻨﻜﻪ ﻳﻚ رآﻮرد ﺑﻪ ﻓﺎﻳﻞ ﻧﻮﺷﺘﻪ ﻳﺎ از ﻓﺎﻳﻞ ﺧﻮاﻧـﺪﻩ ﺷـﺪ‪ ،‬رآـﻮرد ﺑﻌـﺪ از ﺁن ﺑـﻪ ﻋﻨـﻮان رآـﻮرد‬ ‫ﺟﺎري در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد‪.0‬ﺷﺪﻩ اﺳﺖ‪.NET‬از آﻠﻤﻪ آﻠﻴﺪي ‪ Structure‬ﺟﻬﺖ ﺗﻌﺮﻳـﻒ ﻳـﻚ ﺳـﺎﺧﺘﺎر ﺳﻔﺎرﺷـﻲ اﺳـﺘﻔﺎدﻩ‬ ‫ﻣﻲ آﻨﻴﻢ‪ .‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،record_number‬ﺷﻤﺎرﻩ رآﻮردي اﺳﺖ آﻪ ﺑﺎﻳﺪ ﺧﻮاﻧﺪﻩ ﻳﺎ ﻧﻮﺷﺘﻪ ﺷﻮد‪.‬در ﺗﺎﺑﻊ )(‪(FilePut‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،value‬ﻣﺘﻐﻴﺮ رآﻮردي اﺳﺖ آﻪ در ﻓﺎﻳﻞ ﻧﻮﺷﺘﻪ ﺷﺪﻩ اﺳﺖ ﻳﺎ ﻣﻲ ﺷﻮد‪.‬‬ ‫ﺑﺮاي آﺎر ﺑﺎ اﻳﻦ ﺗﻮاﺑﻊ ﻧﻴﺎز ﺑﻪ داﻧﺴﺘﻦ ﺷﻤﺎرﻩ رآﻮردي دارﻳﺪ آـﻪ ﻣـﻲ ﺧﻮاهﻴـﺪ ﺁن را ﺑﺨﻮاﻧﻴـﺪ ﻳـﺎ در‬ ‫ﻓﺎﻳﻞ ﺑﻨﻮﻳﺴﻴﺪ‪.record_number‬‬ ‫اﻳﻦ دو ﺗﺎﺑﻊ ﺑﺮاي ﺧﻮاﻧﺪن ﻳﺎ ﻧﻮﺷﺘﻦ رآﻮردهﺎ ﺑﻪ ﻳﺎ از ﻓﺎﻳﻞ ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‪.Description = “SONY TV‬‬ ‫‪PRec.‬اﻳﻦ آﻠﻤﻪ ﺟﺎﻳﮕﺰﻳﻦ آﻠﻤﻪ آﻠﻴﺪي ‪ Type‬در ‪ VB.99‬‬ ‫اآﻨﻮن هﻤﻪ ﭼﻴﺰ ﺑﺮاي ذﺧﻴﺮﻩ آﺮدن ﻣﻘﺎدﻳﺮ وارد ﺷﺪﻩ در ﻓﺎﻳﻞ ﻣﺎ ﺁﻣﺎدﻩ اﺳﺖ اﻣﺎ ﻗﺒﻞ از اﻧﺠـﺎم اﻳـﻦ‬ ‫آﺎر ﺑﺎﻳﺪ ﻓﺎﻳﻞ را اﻳﺠﺎد آﻨﻴﻢ‪:‬‬ ‫)(‪fNum =FreeFile‬‬ ‫)‪FileOpen(fNum.record_number ]) .‬از ﺁﻧﺠﺎﺋﻴﻜﻪ ﻓﻴﻠﺪهﺎي ﻣﺎ داراي ﻣﻘﺎدﻳﺮ رﺷﺘﻪ اي هﺴﺘﻨﺪ و ﻃـﻮل ﺁﻧﻬـﺎ از ﻗﺒـﻞ‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬‬ ‫از ﺁﻧﺠﺎﻳﻲ آﻪ ﻓﺎﻳﻞ ﺑﺎ ﺳﺎﺧﺘﺎر دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ‪ ،‬اﻧﻌﻄﺎف ﭘﺬﻳﺮﺗﺮﻳﻦ ﺳﺎﺧﺘﺎر و ﺑﻴﺸﺘﺮﻳﻦ آﺎرﺑﺮد را‬ ‫دارد‪ ،‬ﺑﺎ ذآﺮ ﭼﻨﺪ ﻣﺜﺎل ﺑﺎ ﻧﺤﻮﻩ ﻋﻤﻠﻜﺮد اﻳﻦ ﺳﺎﺧﺘﺎر ﺑﻴﺸﺘﺮ ﺁﺷﻨﺎ ﻣﻲ ﺷﻮﻳﻢ‪:‬‬ ‫در اﻳﻨﺠﺎ ﻣﻦ ﻗﺼﺪ اﻳﺠﺎد ﻳﻚ ﻓﺎﻳﻞ ﻧﻮع دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ را ﺟﻬـﺖ ﻧﮕﻬـﺪاري ﻣﺸﺨـﺼﺎت ﻣﺤـﺼﻮل‬ ‫ﻳﻚ ﺷﺮآﺖ دارم‪ .OpenMode.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،file_number‬ﺷﻤﺎرﻩ ﻓﺎﻳﻞ اﺳﺖ‪.value [.NET‬‬ ‫‪٤٩‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .value [.‬‬ ‫ﺣــﺎﻻ ﺑــﺮاي دﺳﺘﺮﺳــﻲ ﺑــﻪ ﻓﻴﻠــﺪهﺎي اﻳــﻦ ﺳــﺎﺧﺘﺎر ﺑﺎﻳــﺪ ﻣﺘﻐﻴــﺮي از ﻧــﻮع اﻳــﻦ ﺳــﺎﺧﺘﺎر ﻳﻌﻨــﻲ‬ ‫‪ ProductRecord‬ﺗﻌﺮﻳﻒ آﻨﻴﻢ‪:‬‬ ‫‪Dim PRec As ProductRecord‬‬ ‫ﺣﺎل ﻣﻲ ﺗﻮاﻧﻴﻢ ﻣﻘﺎدﻳﺮ ﺧﻮد را ﺑﻪ ﻓﻴﻠﺪهﺎي ﻣﺘﻐﻴﺮ ‪ Prec‬ﻧﺴﺒﺖ دهﻴﻢ‪:‬‬ ‫” ‪PRec.

‫ﻣﺸﺨﺺ ﻧﻴﺴﺖ )ﻣﺘﻐﻴﺮ اﺳﺖ(‪ ،‬اﺟﺎزﻩ ﻣﻲ دهﻴﻢ آﻪ ﺗﺎﺑﻊ ﺑﻪ ﻃﻮر ﺧﻮدآﺎر رآﻮردهـﺎ را ادارﻩ و ﻃـﻮل‬
‫ﺁﻧﻬﺎ را ﻣﺪﻳﺮﻳﺖ آﻨﺪ‪ .‬اﺻﻮل آﺎر ﺑﻪ اﻳﻦ ﺷﻜﻞ اﺳﺖ آﻪ هﻨﮕﺎم ذﺧﻴﺮﻩ ﻣﺘﻐﻴﺮ رﺷﺘﻪ اي‪ ،‬ﻃﻮل ﺁن ﻧﻴـﺰ‬
‫هﻤﺮاﻩ ﺑﺎ ﻣﻘﺪار ﺁن در ﻓﺎﻳﻞ ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮد ﭘﺲ ﺷﻤﺎ ﻧﻴﺎزي ﺑﻪ داﻧﺴﺘﻦ ﻃﻮل هﺮ رآﻮرد ﻧﺪارﻳﺪ‪.‬‬
‫و ﺣﺎﻻ ﻣﻘﺎدﻳﺮ ﻧﺴﺒﺖ دادﻩ ﺷﺪﻩ را ﺑﺎ دﺳﺘﻮر زﻳﺮ در ﻓﺎﻳﻞ ذﺧﻴﺮﻩ ﻣﻲ آﻨﻴﻢ‪:‬‬
‫)‪FilePut(fNum,Prec‬‬

‫ﺗﻮﺟﻪ آﻨﻴﺪ آﻪ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ از ذآﺮ ﺁﺧﺮﻳﻦ ﺁرﮔﻮﻣﺎن ﺗﺎﺑﻊ )(‪ FilePut‬آﻪ ﺷـﻤﺎرﻩ ي رآـﻮردي آـﻪ‬
‫ﺑﺎﻳﺪ ﻧﻮﺷﺘﻪ ﺷﻮد را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ‪ ،‬ﺧﻮدداري آﻨﻴﺪ‪.‬‬
‫ﭘﺲ از ذﺧﻴﺮﻩ ﺗﻤﺎﻣﻲ ﻣﻘﺎدﻳﺮ در ﻓﺎﻳﻞ ﺑﺎﻳﺪ ﻓﺎﻳﻞ را ﺑﺴﺖ‪ .‬ﭘﺲ ﺑﺎ دﺳﺘﻮر زﻳﺮ اﻳﻦ آﺎر را ﻣﻲ آﻨﻴﻢ‪:‬‬
‫)‪FileClose(fNum‬‬

‫ﺑﺮاي ﺧﻮاﻧﺪن رآﻮردهﺎ‪ ،‬هﻤﺎن ﺗﺎﺑﻊ )(‪ FileOpen‬آﻪ ﺑﺮاي ذﺧﻴﺮﻩ ﺳﺎزي رآﻮردهﺎ اﺳـﺘﻔﺎدﻩ آـﺮدﻳﻢ‬
‫را ﺑﻪ آﺎر ﻣﻲ ﺑﺮﻳﻢ‪:‬‬
‫)(‪fNum =FreeFile‬‬
‫)‪FileOpen(fNum, “C:\products.dat ”, OpenMode.Random‬‬

‫ﭘﺲ از ﺑﺎز آﺮدن ﻓﺎﻳﻞ ﺟﻬﺖ ﺧﻮاﻧﺪ ﻣﺤﺘﻮﻳﺎن ﺁن‪ ،‬ﻣﻲ ﺗﻮاﻧﻴﻢ ﺑﺎ ﻳﻚ ﺳﺎﺧﺘﺎر ﺗﻜﺮار )‪ (loop‬اﻳﻦ آـﺎر را‬
‫اﻧﺠﺎم دهﻴﻢ‪.‬‬
‫ﻣﺜﺎل زﻳﺮ ﻧﺸﺎن ﻣﻲ دهﺪ آﻪ ﭼﮕﻮﻧﻪ رآﻮردهﺎﻳﻲ ﺑـﺎ ﻃـﻮل ﻣﺘﻔـﺎوت و ﻣﺘﻐﻴـﺮ را ﺑـﺎ اﺳـﺘﻔﺎدﻩ از ﺗـﺎﺑﻊ‬
‫)(‪ FilePut‬در ﻳــﻚ ﻓﺎﻳــﻞ ﺑــﺎ دﺳﺘﺮﺳــﻲ ﺗــﺼﺎدﻓﻲ ذﺧﻴــﺮﻩ و ﺳــﭙﺲ ﺁﻧﻬــﺎ را ﺑــﺎ اﺳــﺘﻔﺎدﻩ از ﺗــﺎﺑﻊ‬
‫)(‪ FileGet‬ﺑﺨﻮاﻧﻴﻢ‪.‬‬
‫اﺑﺘﺪا آﺪ زﻳﺮ را آﻪ ﺳﺎﺧﺘﺎر رآﻮرد ﻣﺎ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨـﺪ در ﻗـﺴﻤﺖ ﺗﻌـﺎرﻳﻒ ﻓـﺮم )‪(declarations‬‬
‫ﺑﻨﻮﻳﺴﻴﺪ‪.‬‬
‫‪Structure ProductRecord‬‬
‫‪Dim ProductID As String‬‬
‫‪Dim Description As String‬‬
‫‪Dim Price As Decimal‬‬
‫‪End Structure‬‬

‫ﺣﺎل آﺪهﺎي زﻳﺮ را در روﻳﺪاد )(‪ Click‬ﻳﻚ دآﻤﻪ ي ﻓﺮم ﻗﺮار دهﻴﺪ‪.‬‬
‫‪Dim PRec As ProductRecord‬‬
‫” ‪PRec.ProductID = “TV00180-A‬‬
‫” ‪PRec.Description = “SONY TV‬‬
‫‪PRec.Price = 799.99‬‬
‫)(‪fNum =FreeFile‬‬
‫)‪FileOpen(fNum,“C:\products.dat ”, OpenMode.Random‬‬
‫)‪FilePut(fNum,PRec‬‬
‫)(‪PRec =New ProductRecord‬‬
‫”‪PRec.ProductID = “TV-Flat‬‬
‫” ‪PRec.Description =“This is a Flat TV‬‬
‫‪PRec.Price = 699.99‬‬
‫)‪FilePut(fNum,PRec‬‬
‫)(‪PRec =New ProductRecord‬‬
‫”‪PRec.ProductID = “TV-FST‬‬
‫” ‪PRec.Description = “And this is the real FST TV‬‬
‫‪Prec.Price = 399.99‬‬
‫)‪FilePut(fNum,Prec‬‬
‫)‪FileClose(fNum‬‬
‫)(‪fNum = FreeFile‬‬
‫)‪FileOpen(fNum, “C:\products.dat ”, OpenMode.Random‬‬

‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬

‫‪٥٠‬‬

‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬

‫)(‪Prec =New ProductRecord‬‬
‫)‪FileGet(fNum,Prec,2‬‬
‫)‪FileClose(fNum‬‬
‫)‪Console.WriteLine(Prec.ProductID‬‬
‫)‪Console.WriteLine(Prec.Description‬‬
‫)‪Console.WriteLine(Prec.Price‬‬

‫هﻤﺎن ﻃﻮر آﻪ ﻣﺸﺎهﺪﻩ ﻣﻲ آﻨﻴﺪ‪ ،‬ﻓﻴﻠـﺪهﺎي ‪ ProductID‬و ‪ Description‬ﻣﺤـﺼﻮﻻت ﻣﺨﺘﻠـﻒ‪،‬‬
‫آﻪ از ﻧﻮع رﺷﺘﻪ اي هﺴﺘﻨﺪ داراي ﻃﻮل هﺎي ﻣﺨﺘﻠﻒ هﺴﺘﻨﺪ‪.‬‬
‫ﺳﻪ ﻗﺴﻤﺖ اول آﺪ ﺑﺎﻻ‪ ٣ ،‬رآﻮرد ﻣﺨﺘﻠﻒ را در ﻓﺎﻳﻞ ﺗﺼﺎدﻓﻲ ذﺧﻴﺮﻩ آﺮدﻩ و ﺳـﭙﺲ ﻓﺎﻳـﻞ را ﻣـﻲ‬
‫ﺑﻨﺪد‪.‬‬
‫ﻗﺴﻤﺖ ﺁﺧﺮ آﺪ ﻧﻴﺰ‪ ،‬دوﻣﻴﻦ رآﻮرد ﻓﺎﻳﻞ را ﺧﻮاﻧﺪﻩ و ﻣﻘﺎدﻳﺮ ﺁن را در ﺧﺮوﺟﻲ ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪.‬‬
‫ﻧﻜﺘﻪ‪ :‬در ‪ ،VB.6.0‬هﺮ رآﻮرد در ﻓﺎﻳﻞ ﺗﺼﺎدﻓﻲ ﺑﺎﻳﺪ داراي ﻃـﻮل ﺛﺎﺑـﺖ ﻣـﻲ ﺑـﻮد اﻣـﺎ در ‪،VB.NET‬‬
‫ﻣﻲ ﺗﻮاﻧﻴﺪ رآﻮردهﺎﻳﻲ اﻳﺠﺎد و در ﻓﺎﻳﻞ ﺗﺼﺎدﻓﻲ ﻗﺮار دهﻴﺪ آﻪ داراي ﻃﻮل ﻣﺘﻐﻴﺮ ﺑﺎﺷﻨﺪ‪.‬‬
‫)‪Write(file_number,output_list) , WriteLine(file_number,output_list‬‬
‫ﺗﺎﺑﻊ )(‪ Write‬ﺟﻬﺖ ذﺧﻴﺮﻩ دادﻩ هﺎ در ﻳﻚ ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ ﺑﻪ آﺎر ﻣﻲ رود‪.‬‬
‫ﺁرﮔﻮﻣﺎن ‪ file_number‬ﺷﻤﺎرﻩ ﻓﺎﻳﻠﻲ اﺳﺖ آﻪ دادﻩ هﺎ در ﺁن ذﺧﻴﺮﻩ ﺧﻮاهﻨﺪ ﺷﺪ‪.‬‬
‫ﺁرﮔﻮﻣﺎن ‪ output_list‬ﻧﻴﺰ آﻪ ﻳﻚ ﺁراﻳﻪ ي ﭘﺎراﻣﺘﺮي اﺳﺖ‪ ،‬ﻟﻴﺴﺘﻲ از دادﻩ هﺎﻳﻲ اﺳـﺖ آـﻪ ﻣـﻲ‬
‫ﺧﻮاهﻴﻢ در ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ ﻧﻮﺷﺘﻪ ﺷﻮﻧﺪ و ﻣﻲ ﺗﻮاﻧﻨﺪ ﻣﺘﻐﻴﺮهـﺎي ﻣﻘـﺪاردهﻲ ﺷـﺪﻩ ﻳـﺎ ﺧـﻮد ﻣﻘـﺪار‬
‫ﻣﻮرد ﻧﻈﺮ ﺑﺎﺷﻨﺪ‪ .‬دادﻩ هﺎ در ﺁرﮔﻮﻣﺎن ‪ ،output_list‬ﺑﺎ آﺎراآﺘﺮ )‪ (,‬از ﻳﻜﺪﻳﮕﺮ ﺟﺪا ﻣﻲ ﺷﻮﻧﺪ‪.‬‬
‫دادﻩ هﺎﻳﻲ آﻪ ﺑﺎ ﺗﺎﺑﻊ )(‪ Write‬در ﻓﺎﻳﻞ ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮﻧﺪ ﻣﻌﻤﻮﻻ ﺑﺎ ﺗـﺎﺑﻊ )(‪ Input‬ﺧﻮاﻧـﺪﻩ ﻣـﻲ‬
‫ﺷﻮﻧﺪ‪.‬‬
‫دﺳﺘﻮرات زﻳﺮ‪ ،‬ﻳﻚ ﻣﻘﺪار ﻋﺪدي و ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ را در ﻳﻚ ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ ﻣﻲ ﻧﻮﻳﺴﻨﺪ‪:‬‬
‫‪NumVal = 3300.004‬‬
‫‪DateVal = #04/09/1999#‬‬
‫)‪Write(1, NumVal, DateVal‬‬

‫ﺗﺎﺑﻊ )(‪ WriteLine‬ﻧﻴﺰ هﻤﺎن آﺎر ﺗﺎﺑﻊ )(‪ Write‬را اﻧﺠﺎم ﻣـﻲ دهـﺪ ﺑـﺎ اﻳـﻦ ﺗﻔـﺎوت آـﻪ ﺑـﺎ هـﺮ ﺑـﺎر‬
‫ﻓﺮاﺧﻮاﻧﻲ اﻳﻦ ﺗﺎﺑﻊ‪ ،‬دادﻩ هﺎ در ﺳﻄﺮ ﺟﺪﻳﺪي از ﻓﺎﻳﻞ ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬
‫ﻧﻜﺘﻪ ﻣﻬﻢ‪ :‬ﺗﻔﺎوت ﺗﻮاﺑﻊ )(‪ Print‬ﺑﺎ )(‪ Write‬و )(‪ WriteLine‬در اﻳﻦ اﺳـﺖ آـﻪ ﺗﻮاﺑـﻊ )(‪Write‬‬
‫ﻳﺎ )(‪ WriteLine‬ﺑﺎﻋﺚ ﻣﻲ ﺷﻮد ﻓﻴﻠﺪهﺎ در هﻨﮕﺎم ﻧﻮﺷﺘﻪ ﺷـﺪن در ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ ﺑـﺎ آﺎﻣـﺎ )‪ (,‬از‬
‫ﻳﻜﺪﻳﮕﺮ ﺟﺪا ﺷﻮﻧﺪ وﻟﻲ در ﺗﺎﺑﻊ )(‪ Print‬ﭼﻨﺎﻧﭽﻪ ﻓﻴﻠﺪهﺎ ﺑﺎ آﺎﻣﺎ از ﻳﻜـﺪﻳﮕﺮ ﺟـﺪا ﺷـﻮﻧﺪ‪ ،‬در هﻨﮕـﺎم‬
‫ذﺧﻴﺮﻩ در ﻓﺎﻳﻞ‪ ،‬ﺑﻴﻦ ﻓﻴﻠﺪهﺎ ‪ ١٤‬ﻓﺎﺻﻠﻪ ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ اﻣﺎ اﮔﺮ ﻓﻴﻠـﺪهﺎ ﺑـﺎ آـﺎراآﺘﺮ );( از ﻳﻜـﺪﻳﮕﺮ‬
‫ﺟﺪا ﺷﻮﻧﺪ‪ ،‬ﻓﻴﻠﺪهﺎ ﺑﺪون ﻓﺎﺻﻠﻪ از ﻳﻜﺪﻳﮕﺮ در ﻓﺎﻳﻞ ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ‪.‬‬
‫ﻣﺜﺎل زﻳﺮ ﺷﺒﻴﻪ ﻣﺜﺎﻟﻲ اﺳﺖ آﻪ در ﺗﻮﺿﻴﺤﺎت ﺗـﺎﺑﻊ )(‪ Print‬ﺁﻣـﺪ اﻣـﺎ اﻳـﻦ ﺑـﺎر ﺑـﺎ اﺳـﺘﻔﺎدﻩ از ﺗـﺎﺑﻊ‬
‫)(‪ WriteLine‬ﺁن را ﻣﻲ ﻧﻮﻳﺴﻴﻢ‪:‬‬
‫)(‪Dim fNum As Integer = FreeFile‬‬
‫)‪FileOpen(fNum, “C:\test.txt”, OpenMode.Output‬‬
‫)” ‪WriteLine(fNum, “Behrouz Rad”, 33, “Manager‬‬
‫)” ‪WriteLine(fNum, “Sina Ahmadi”, 24, “Programmer‬‬
‫)” ‪WriteLine(fNum, “Arvin Sanaei”, 37, “Engineer‬‬
‫)” ‪WriteLine(fNum, “Pedram Amiri”, 28, “Administrator‬‬

‫ﺧﺮوﺟﻲ دﺳﺘﻮرات ﻓﻮق ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺧﻮاهﺪ ﺷﺪ‪:‬‬

‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬

‫”‪“Behrouz Rad”, 33, ”Manager‬‬
‫”‪“Sina Ahmadi”, 24, ”Programmer‬‬
‫”‪“Arvin Sanaei”, 37, ”Engineer‬‬
‫”‪“Pedram Amiri”, 28, ”Administrator‬‬

‫‪٥١‬‬

‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬

‫)‪Seek(file_number [,position ]) , Loc(file_number‬‬
‫ﺗﺎﺑﻊ )(‪ ،Loc‬ﻣﻜﺎن ﺟﺎري اﺷﺎرﻩ ﮔﺮ ﻓﺎﻳﻞ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.‬‬
‫ﺗﺎﺑﻊ )(‪ Seek‬ﻧﻴﺰ در ﺻﻮرﺗﻲ آﻪ ﺑﺪون ذآﺮ ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ position‬ﺑﻪ آﺎر رود‪ ،‬ﻋﻤﻠﻲ ﻣـﺸﺎﺑﻪ‬
‫ﺗﺎﺑﻊ )(‪ Loc‬را اﻧﺠﺎم ﻣﻲ دهﺪ‪.‬‬
‫در ﻓﺎﻳﻞ هﺎي ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ‪ ،‬ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ دو ﺗﺎﺑﻊ‪ ،‬ﺷﻤﺎرﻩ ﺁﺧـﺮﻳﻦ رآـﻮردي اﺳـﺖ‬
‫آﻪ از ﻓﺎﻳﻞ ﺧﻮاﻧﺪﻩ ﺷﺪﻩ ﻳﺎ در ﻓﺎﻳﻞ ﻧﻮﺷﺘﻪ ﺷﺪﻩ‪.‬‬
‫در ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ‪ ،‬اﻳﻦ ﻣﻘﺪار‪ ،‬ﺑﺎ ﺗﻘﺴﻴﻢ ﺑﺎﻳﺖ ﺧﻮاﻧﺪﻩ ﺷﺪﻩ ﺟﺎري ﺑﺮ ﻋﺪد ‪ ١٢٨‬ﺑﻪ دﺳـﺖ ﻣـﻲ‬
‫ﺁﻳﺪ‪.‬‬
‫در ﻓﺎﻳﻞ هﺎي ﺑﺎﻳﻨﺮي ﻧﻴﺰ‪ ،‬ﺷﻤﺎرﻩ ﺁﺧﺮﻳﻦ ﺑﺎﻳﺖ ﺧﻮاﻧﺪﻩ ﺷﺪﻩ از ﻳﺎ ﻧﻮﺷﺘﻪ ﺷـﺪﻩ ﺑـﻪ ﻓﺎﻳـﻞ ﺑـﻪ ﻋﻨـﻮان‬
‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ ﺧﻮاهﺪ ﺑﻮد‪.‬‬
‫ﺷﻤﺎ ﻗﺎدر ﺑﻪ ﺗﻌﻴﻴﻦ ﻣﻜﺎن ﺷﺮوع ﺧﻮاﻧﺪن ﻳﺎ ﻣﻜﺎن ﻧﻮﺷﺘﻪ ﺷﺪن رآـﻮرد در ﻓﺎﻳـﻞ ﺑـﺎ ﻣﻘـﺪاردهﻲ ﺑـﻪ‬
‫ﺁرﮔﻮﻣﺎن ‪ position‬از ﺗﺎﺑﻊ )(‪ Seek‬هﺴﺘﻴﺪ‪.‬‬
‫ﻣﺜﻼ ﺑﺮاي ﺁﻧﻜﻪ اﺷﺎرﻩ ﮔﺮ رآﻮرد را در ﻳﻚ ﻓﺎﻳﻞ ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ ﺑﻪ ﺳﻮﻣﻴﻦ رآﻮرد ﺑﺒﺮﻳﺪ ﻳﺎ ﺑـﻪ‬
‫ﻋﺒﺎرت دﻳﮕﺮ ﺁن را ﺑﻪ ﻋﻨﻮان رآﻮرد ﻓﻌﺎل ﻣﻨﻈﻮر آﻨﻴﺪ‪ ،‬ﻣﻲ ﺗﻮاﻧﻴﺪ از دﺳﺘﻮر زﻳﺮ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪:‬‬
‫)‪Seek(fNum,3‬‬

‫‪Lock(file_number [,fromRecord ][,toRecord ]) ,‬‬
‫)] ‪Unlock(file_number [,fromRecord ][,toRecord‬‬
‫ﺗﺎﺑﻊ )(‪ Lock‬اﻳﻦ اﻣﻜﺎن را ﺑﺮاي ﺷﻤﺎ ﻓـﺮاهﻢ ﻣـﻲ آﻨـﺪ آـﻪ ﻳـﻚ ﻓﺎﻳـﻞ ﺑـﺎ دﺳﺘﺮﺳـﻲ ﺗـﺼﺎدﻓﻲ ﻳـﺎ‬
‫ﺗﻌﺪادي از رآﻮردهﺎي ﺁن را ﻗﻔﻞ آﻨﻴﺪ‪.‬‬
‫ﺁرﮔﻮﻣﺎن ‪ file_number‬ﺷﻤﺎرﻩ ﻓﺎﻳﻞ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ‪.‬‬
‫ﺗﻮﺟﻪ‪ :‬ﺁرﮔﻮﻣﺎن هﺎي اﺧﺘﻴﺎري ‪ fromRecord‬و ‪ toRecord‬را زﻣﺎﻧﻲ ﺑﻪ آﺎر ﺑﺒﺮﻳـﺪ آـﻪ ﻗـﺼﺪ ﻗﻔـﻞ‬
‫آﺮدن ﺗﻌﺪادي از رآﻮردهﺎي ﻓﺎﻳﻞ را دارﻳﺪ ﻧﻪ هﻤﻪ رآﻮردهﺎ را‪.‬‬
‫ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺁرﮔﻮﻣﺎن هﺎي ‪ fromRecord‬و ‪ toRecord‬ﻗﺎدر ﺑﻪ ﺗﻌﺮﻳﻒ ﻣﺤﺪودﻩ اي ﺟﻬـﺖ ﻗﻔـﻞ‬
‫آﺮدن و ﺑﻪ اﻧﺤﺼﺎر در ﺁوردن رآﻮردهﺎ هﺴﺘﻴﺪ‪ .‬ﺁرﮔﻮﻣﺎن ‪ fromRecord‬ﺗﻌﻴـﻴﻦ ﻣـﻲ آﻨـﺪ آـﻪ ﻗﻔـﻞ‬
‫ﮔﺬاري از آﺪام رآﻮرد ﺷﺮوع ﺷﺪﻩ و ﺁرﮔﻮﻣﺎن ‪ toRecord‬ﻧﻴﺰ ﺗﻌﻴﻴﻦ ﻣـﻲ آﻨـﺪ آـﻪ ﻗﻔـﻞ ﮔـﺬاري ﺗـﺎ‬
‫آﺪام رآﻮرد اداﻣﻪ ﭘﻴﺪا آﻨﺪ‪.‬‬
‫ﻣﺜﻼ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺗﻌﻴﻴﻦ آﻨﻴﺪ آﻪ رآﻮردهﺎي ‪ ٥‬ﺗﺎ ‪ ١٠‬در ﻓﺎﻳﻞ‪ ،‬ﻗﻔﻞ ﺷﻮﻧﺪ‪.‬‬
‫ﻧﻜﺎت ﻣﻬﻢ در اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪:Lock‬‬
‫‪(١‬در ﺻﻮرﺗﻲ آﻪ از ذآﺮ دو ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري اﻳﻦ ﺗﺎﺑﻊ ﺧﻮدداري ﺷﻮد‪ ،‬ﺗﻤﺎم رآﻮردهـﺎي ﻓﺎﻳـﻞ ﻗﻔـﻞ‬
‫ﺧﻮاهﻨﺪ ﺷﺪ‪.‬‬
‫‪ (٢‬در ﺻــﻮرﺗﻲ آــﻪ ﻓﻘــﻂ ﺑــﺮاي ﺁرﮔﻮﻣــﺎن ‪ fromRecord‬ﻣﻘــﺪار ذآــﺮ ﺷــﻮد و ﺁرﮔﻮﻣــﺎن ‪toRecord‬‬
‫ﻣﻘﺪاردهﻲ ﻧﺸﻮد‪ ،‬رآﻮردهﺎ از ﻣﻘﺪار ‪ fromRecord‬ﺗﺎ ﺑﻪ اﻧﺘﻬﺎي ﻓﺎﻳﻞ ﻗﻔﻞ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬
‫‪ (٣‬رآﻮردهﺎﻳﻲ آﻪ ﺑﺎ اﻳﻦ ﺗـﺎﺑﻊ ﻗﻔـﻞ ﻣـﻲ ﺷـﻮﻧﺪ‪ ،‬رآﻮردهـﺎي اﻧﺤـﺼﺎري هـﺴﺘﻨﺪ آـﻪ ﻓﻘـﻂ ﺗﻮﺳـﻂ‬
‫ﺑﺮﻧﺎﻣــﻪ ﺷــﻤﺎ ﻗﺎﺑــﻞ اﺳــﺘﻔﺎدﻩ ﺑــﻮدﻩ و ﺑﺮﻧﺎﻣــﻪ هــﺎي دﻳﮕــﺮ در ﺣــﺎل اﺟــﺮا ﻣﺠــﺎز ﺑـﻪ اﺳــﺘﻔﺎدﻩ از ﺁﻧﻬــﺎ‬
‫ﻧﻴﺴﺘﻨﺪ‪.‬‬
‫‪ (٤‬اﮔﺮ ﺑﺮﻧﺎﻣﻪ اي دﻳﮕﺮ در ﺟﻬﺖ دﺳﺘﺮﺳﻲ ﺑﻪ ﻓﺎﻳﻞ ﻳﺎ رآﻮردهﺎﻳﻲ آﻪ ﺗﻮﺳﻂ ﺷﻤﺎ ﻗﻔﻞ ﺷـﺪﻩ اﻧـﺪ‬
‫اﻗﺪام ﻧﻤﺎﻳﺪ‪ ،‬ﺧﻄﺎﻳﻲ در ﺑﺮﻧﺎﻣﻪ اﺗﻔﺎق ﻣﻲ اﻓﺘﺪ آﻪ ﺑﺎﻳﺪ ﺗﻮﺳﻂ ﺗﻌﺮﻳﻒ ﺳـﺎﺧﺘﺎر ﺧﻄـﺎ در ﺑﺮﻧﺎﻣـﻪ‪ ،‬ﺁن‬
‫را آﻨﺘﺮل آﺮدﻩ و از ﭘﺎﻳﺎن ﺑﺮﻧﺎﻣﻪ ﺟﻠﻮﮔﻴﺮي آﻨﻴﺪ‪.‬‬
‫ﺗﺎﺑﻊ )(‪ Unlock‬ﻧﻴﺰ دﻗﻴﻘﺎ ﺑﺎﻟﻌﻜﺲ ﺗﺎﺑﻊ ‪ Lock‬ﻋﻤﻞ آﺮدﻩ و ﻓﺎﻳﻞ ﻳـﺎ رآﻮردهـﺎي ﻗﻔـﻞ ﺷـﺪﻩ را ﺁزاد‬
‫ﻣﻲ آﻨﺪ‪.‬‬

‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬

‫‪٥٢‬‬

‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬

‬‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪ ،‬در ﺟﺪول زﻳﺮ ﻣﺸﺎهﺪﻩ ﻣﻲ آﻨﻴﺪ‪:‬‬ ‫ﻣﻘﺎدﻳﺮي آﻪ ﺗﺎﺑﻊ )(‪ FileAttr‬ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‬ ‫ﻣﺪ ﺑﺎز ﺷﺪن‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ‬ ‫‪1‬‬ ‫‪Input‬‬ ‫‪2‬‬ ‫‪Output‬‬ ‫‪4‬‬ ‫‪Random‬‬ ‫‪8‬‬ ‫‪Append‬‬ ‫‪32‬‬ ‫‪Binary‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬ ‫‪٥٣‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫در ﺻــﻮرﺗﻲ آــﻪ آﺎراآﺘﺮهــﺎي ﺷــﻤﺎ از ﺗﻌــﺪاد ﺗﻌﻴــﻴﻦ ﺷــﺪﻩ در ﺁرﮔﻮﻣــﺎن ‪ length‬ﺑﻴــﺸﺘﺮ ﺑﺎﺷــﺪ‪،‬‬ ‫آﺎراآﺘﺮهﺎي اﺿﺎﻓﻲ ﺑﻪ ﻃﻮر اﺗﻮﻣﺎﺗﻴﻚ ﺑﻪ ﺧﻂ ﺑﻌﺪ ﻣﻨﺘﻘﻞ ﻣﻲ ﺷﻮﻧﺪ‪.length‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻧﻴﺰ ﻳﻚ ﺑﺴﻴﺎر ﺑـﺴﻴﺎر آﺎرﺁﻣـﺪ اﺳـﺖ آـﻪ ﺟﻬـﺖ ﺗﻌﻴـﻴﻦ ﺑﻴـﺸﺘﺮﻳﻦ ﻃـﻮل ﺧـﻂ ﻳﻌﻨـﻲ ﺗﻌـﺪاد‬ ‫آﺎراآﺘﺮهﺎي ﻗﺎﺑﻞ ذﺧﻴﺮﻩ ﺳﺎزي در هﺮ ﺧﻂ آﻪ ﻣﻲ ﺗﻮاﻧﺪ در ﻳﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ ﻧﻮﺷـﺘﻪ ﺷـﻮد‪ ،‬ﺑـﻪ‬ ‫آﺎر ﻣﻲ رود‪.‫)‪Width(fNum.‬‬ ‫هﻤﭽﻨﻴﻦ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺗﺎﺑﻊ )(‪ Width‬را ﺑﺎ ﺗﻮاﺑﻊ )(‪ PrintLine‬و )(‪ WriteLine‬ﻧﻴـﺰ )آـﻪ دادﻩ هـﺎ را‬ ‫در ﺧﻄﻮط ﺟﺪا ذﺧﻴﺮﻩ ﻣﻲ آﻨﻨﺪ( ﺑﻪ آﺎر ﺑﺒﺮﻳﺪ‪.‬‬ ‫)‪FileAttr(file_number‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻳﻚ ﻋﺪد از ﻧﻮع ‪ Integer‬را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ آﻪ ﻣـﺸﺨﺺ آﻨﻨـﺪﻩ ي ﺣﺎﻟـﺖ ﺑـﺎز ﺷـﺪن‬ ‫ﻳﻚ ﻓﺎﻳﻞ ﺑﺎز اﺳﺖ‪.‬‬ ‫اﺑﻦ ﺗﺎﺑﻊ را ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺎ ﺗﻮاﺑﻊ )(‪ Print‬و )(‪) Write‬آﻪ دادﻩ هـﺎ را در ﻳـﻚ ﺧـﻂ و ﭘـﺸﺖ ﺳـﺮ هـﻢ‬ ‫ذﺧﻴﺮﻩ ﻣﻲ آﻨﻨﺪ( ﺟﻬﺖ ﺗﻌﻴﻴﻦ ﺗﻌﺪاد آﺎراآﺘﺮهﺎي ذﺧﻴﺮﻩ ﺷﻮﻧﺪﻩ در هﺮ ﺧﻂ‪ ،‬ﺑﻪ آﺎر ﺑﺮﻳﺪ‪.‬‬ ‫ﺑﻴﺸﺘﺮﻳﻦ ﻃﻮل ﺧﻂ ﺑﻪ وﺳﻴﻠﻪ ي ﺁرﮔﻮﻣﺎن ‪ length‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد‪.

‬ﭘﻴﺸﻨﻬﺎد ﻣﻲ آﻨﻢ هﻤﻴﺸﻪ در ﺗﻮﻟﻴﺪ اﻋﺪاد ﺗـﺼﺎدﻓﻲ‪ ،‬ﻣﻘـﺪار ‪ seed‬را ﺑـﺎ ﻋـﺪد‬ ‫ﻳﻚ ﺟﻤﻊ آﻨﻴﺪ‪.‬‬ ‫ﺗﻮﺟﻪ‪ :‬ﺗﺎﺑﻊ ‪ Next‬ﻧﻴﺰ آﻪ در آﻼس ‪ System.Random‬ﻗـﺮار‬ ‫دادﻩ ﺷﺪﻩ اﻧﺪ‪.‬‬ ‫ﺑﺮاي ﺟﻠﻮﮔﻴﺮي از اﻳﻦ آـﺎر و ﺗﻐﻴﻴـﺮ ﺗﺮﺗﻴـﺐ ﺗﻮﻟﻴـﺪ اﻋـﺪاد ﺗـﺼﺎدﻓﻲ‪ ،‬از ﺗـﺎﺑﻊ )(‪ Randomize‬آـﻪ در‬ ‫ﻗﺴﻤﺖ ﺑﻌﺪي ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻩ اﺳﺖ‪ ،‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.‬ﺑﺪﻳﻦ ﻣﻨﻈﻮر ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ آﻨﻴﺪ‪:‬‬ ‫)‪randomNumber =Int((upper – lower + 1) * Rnd() + lower‬‬ ‫در اﻳﻦ دﺳﺘﻮر‪ ،‬ﻣﺘﻐﻴﺮ ‪ ،upper‬ﺣﺪ ﺑـﺎﻻي ﻣﺤـﺪودﻩ ي ﻣـﺎ )ﻣـﺜﻼ ‪ (10‬و ﻣﺘﻐﻴـﺮ ‪ ،lower‬ﺣـﺪ ﭘـﺎﻳﻴﻦ‬ ‫ﻣﺤﺪودﻩ )ﻣﺜﻼ ‪ (5‬اﺳﺖ‪.‬‬ ‫ﻧﻜﺘﻪ‪ :‬هﻤﻴﺸﻪ ﺑﻴﻦ ﺗﺎﺑﻊ )(‪ Rnd‬و ﻋﺪدي آﻪ ﻣﻲ ﺧﻮاهﻴﺪ ﻋﺪد ﺗﺼﺎدﻓﻲ ﺑﺮ ﻣﺒﻨﺎي ﺁن ﺗﻮﻟﻴﺪ ﺷـﻮد‪،‬‬ ‫از آﺎراآﺘﺮ )*( اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.‬‬ ‫ﺗﻮﺟﻪ‪ :‬ﺗﺮﺗﻴﺐ ﺗﻮﻟﻴﺪ اﻋﺪاد ﺗﺼﺎدﻓﻲ در اﻳـﻦ ﺗـﺎﺑﻊ هﻤﻴـﺸﻪ ﺑـﻪ ﻳـﻚ ﻣﻨـﻮال اﺳـﺖ‪ .795186‬ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﺪ ﺷﺪ‪.‬‬ ‫] ‪Randomize [seed‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬هﺴﺘﻪ ي ﺗﻮﻟﻴﺪ اﻋﺪاد ﺗﺼﺎدﻓﻲ را ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ‪.‬ﮔﺎهﻲ اوﻗﺎت ﻧﻴﺎز دارﻳﺪ ﺗﺎ ﺑـﻴﻦ ﻣﺤـﺪودﻩ اي دﻟﺨـﻮاﻩ‬ ‫ﻣﺜﻼ‪ 5 :‬ﺗﺎ ‪ ،10‬ﻋﺪدي ﺗﺼﺎدﻓﻲ اﻳﺠﺎد آﻨﻴﺪ‪ .‬‬ ‫ﻧﻜﺘﻪ‪ :‬در آﺪ ﺑﺎﻻ‪ ،‬ﺟﻤﻊ آﺮدن ﻧﺘﻴﺠﻪ ﻗﺴﻤﺖ اول ﺑﺎ ﻋﺪد ‪ ،1‬از ﺗﻮﻟﻴﺪ ﻋﺪد ﺗﺼﺎدﻓﻲ ﺑﻴﻦ ﺻﻔﺮ و ﻳـﻚ‬ ‫ﺟﻠﻮﮔﻴﺮي ﻣﻲ آﻨﺪ‪ .0‬ﺑﺮاي درﺳﺖ آﺮدن اﻋﺪاد ﺗﺼﺎدﻓﻲ ﺑﻪ آـﺎر ﻣـﻲ روﻧـﺪ )‪ Rnd‬و‬ ‫‪ (Randomize‬را ﭘﺸﺘﻴﺒﺎﻧﻲ ﻣﻲ آﻨﺪ اﻣﺎ از ﺁﻧﺠﺎ آﻪ در ‪ ،VB.055475‬‬ ‫‪ (5.Random‬ﻗﺮار دارد ﻗﺎدر ﺑﻪ اﻳﺠﺎد ﻳﻚ ﻋﺪد ﺗـﺼﺎدﻓﻲ‬ ‫در ﻣﺤﺪودﻩ اي ﺧﺎص اﺳﺖ‪.NET‬‬ ‫‪٥٤‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬ﺑﻬﺘﺮ اﺳﺖ از ذآﺮ اﻳﻦ ﻣﻘﺪار ﺧﻮدداري آﻨﻴﺪ‪.‬‬ ‫ﻣﺜﻼ دﺳﺘﻮر ‪ ،Rnd()*10‬ﻳﻚ ﻋﺪد ﺗﺼﺎدﻓﻲ ﺑﻴﻦ ﺻﻔﺮ و دﻩ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.33424 ،7.‬‬ ‫ﻣﺜﻼ‪:‬‬ ‫‪Dim I as Integer‬‬ ‫)(‪Randomize‬‬ ‫‪I = Rnd() * 10‬‬ ‫اﮔﺮ ﻣﻘﺪاري در ﺁرﮔﻮﻣﺎن ‪ seed‬ذآﺮ ﺷﻮد‪ ،‬ﻋﺪد ﺗـﺼﺎدﻓﻲ آـﻪ اﻳﺠـﺎد ﺧﻮاهـﺪ ﺷـﺪ‪ ،‬ﺑـﻴﻦ ﺻـﻔﺮ ﺗـﺎ ﺁن‬ ‫ﻋﺪدي اﺳﺖ آﻪ در ﺁرﮔﻮﻣﺎن ‪ seed‬ذآﺮ ﺷﺪﻩ‪ .‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺮاي اﻳﺠﺎد اﻋﺪاد ﺗﺼﺎدﻓﻲ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‬ ‫)‪:(Random Numbers‬‬ ‫‪ VB.‬‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،seed‬ﻳﻚ ﻋﺒﺎرت ﻋﺪدي اﺳﺖ آﻪ ﻋﺪد ﺗﺼﺎدﻓﻲ ﺑﺎﻳﺪ ﺑﺮ ﺣﺴﺐ ﺁن ﺗﻮﻟﻴﺪ ﺷﻮد‪.‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ هﻤﻴﺸﻪ ﺑﺎ ﺗﺎﺑﻊ )(‪ Rnd‬ﺑﻪ آﺎر ﻣﻲ رود و ﻣﻌﻤﻮﻻ ﻗﺒﻞ از ﺁن ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮد‪.‬‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،seed‬ﻳﻚ ﻣﻘﺪار ﻋﺪدي اﺳﺖ آﻪ ﺑﺮاي ﺗﻮﻟﻴﺪ هﺴﺘﻪ ي اﻋﺪاد ﺗـﺼﺎدﻓﻲ ﺑـﻪ آـﺎر‬ ‫ﻣﻲ رود‪ .6.NET‬دو ﺗﺎﺑﻌﻲ آﻪ در ‪ VB.NET‬اآﺜـﺮ ﺗﻮاﺑـﻊ‪ ،‬دﺳـﺘﻪ ﺑﻨـﺪي و در‬ ‫آﻼس ﺧﺎص ﺧﻮدﺷﺎن ﻗﺮار دادﻩ ﺷﺪﻩ اﻧﺪ‪ ،‬اﻳـﻦ دو ﺗـﺎﺑﻊ ﻧﻴـﺰ در آـﻼس ‪ System.‬‬ ‫)] ‪Rnd([seed‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬در ﺻﻮرﺗﻲ آﻪ ﺑﺪون ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ﺧﻮد ﺑﻪ آﺎر رود‪ ،‬ﻳﻚ ﻋﺪد ﺗﺼﺎدﻓﻲ ﺑـﻴﻦ ﺻـﻔﺮ و ﻳـﻚ‬ ‫را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬ﻣـﺜﻼ اﮔـﺮ دﺳـﺘﻮر‬ ‫‪ Rnd()*10‬را ‪ ٣‬ﺑﺎر ﭘﺸﺖ ﺳﺮ هﻢ اﺟـﺮا آﻨـﻴﻢ‪ ،‬هﻤﻴـﺸﻪ ﺳـﻪ ﻋـﺪد )‪،5.

green.‬‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻋﺪدي از ﻧﻮع ‪ Long‬اﺳﺖ آﻪ آﺪ رﻧﮓ ﺗﻮﻟﻴﺪ ﺷﺪﻩ را ﻧﺸﺎن ﻣﻲ دهﺪ‪.‬‬ ‫ﺗﻌـــﺪاد رﻧـــﮓ هـــﺎي ﻣﻮﺟـــﻮد در ﻣـــﺪل ‪ ١٦٧٧٧٢١٦ ،RGB‬رﻧـــﮓ اﺳـــﺖ آـــﻪ از ﺿـــﺮب ‪ ٣‬ﻋـــﺪد‬ ‫)‪ (256*256*256‬ﺑﻪ دﺳﺖ ﻣﻲ ﺁﻳﺪ‪.0‬وﺟـﻮد داﺷـﺘﻨﺪ‪ ،‬در ‪VB.6.‬‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ اﻳﻦ ﺁرﮔﻮﻣﺎن ﻣﻲ ﺗﻮاﻧﺪ ﺑﭙﺬﻳﺮد‪ ،‬در ﺟﺪول زﻳﺮ ﺁﻣﺪﻩ اﺳﺖ‪:‬‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ color‬در ﺗﺎﺑﻊ )(‪QBColor‬‬ ‫رﻧﮓ‬ ‫ﻣﻘﺪار‬ ‫ﺳﻴﺎﻩ‬ ‫‪0‬‬ ‫ﺁﺑﻲ‬ ‫‪1‬‬ ‫ﺳﺒﺰ‬ ‫‪2‬‬ ‫ﻻﺟﻮردي‬ ‫‪3‬‬ ‫ﻗﺮﻣﺰ‬ ‫‪4‬‬ ‫ارﻏﻮاﻧﻲ‬ ‫‪5‬‬ ‫زرد‬ ‫‪6‬‬ ‫ﺳﻔﻴﺪ‬ ‫‪7‬‬ ‫ﺧﺎآﺴﺘﺮي‬ ‫‪8‬‬ ‫ﺁﺑﻲ روﺷﻦ‬ ‫‪9‬‬ ‫ﺳﺒﺰ روﺷﻦ‬ ‫‪10‬‬ ‫ﻻﺟﻮردي روﺷﻦ‬ ‫‪11‬‬ ‫ﻗﺮﻣﺰ روﺷﻦ‬ ‫‪12‬‬ ‫ارﻏﻮاﻧﻲ روﺷﻦ‬ ‫‪13‬‬ ‫زرد روﺷﻦ‬ ‫‪14‬‬ ‫ﺳﻔﻴﺪ روﺷﻦ )ﺑﺎ ﺷﺪت ﺑﺎﻻ(‬ ‫‪15‬‬ ‫آﺎرﺑﺮد اﻳﻦ ﺗﺎﺑﻊ ﺑﻴﺸﺘﺮ در ﺳﻴﺴﺘﻢ هﺎﻳﻲ اﺳﺖ آﻪ آﺎرت ﮔﺮاﻓﻴﻚ ﺁﻧﻬﺎ ﻧﺼﺐ ﻧﺸﺪﻩ ﻳﺎ ﺗﻨﻬﺎ ﻗـﺎدر ﺑـﻪ‬ ‫ﭘﺸﺘﻴﺒﺎﻧﻲ از ‪ ١٦‬رﻧﮓ ﻣﻲ ﺑﺎﺷﻨﺪ آﻪ در ﺳﻴﺴﺘﻢ هﺎي ﻗﺪﻳﻤﻲ آﺎرﺑﺮد ﺑﻴﺸﺘﺮي دارد‪.‬‬ ‫رﻧﮓ هﺎي اﻳﻦ ﻣﺪل ﻋﺒﺎرﺗﻨﺪ از‪ :‬ﻗﺮﻣﺰ )‪ ،(Red‬ﺳﺒﺰ )‪ ،(Green‬ﺁﺑﻲ )‪(Blue‬‬ ‫ﻧﺎم اﻳﻦ ﻣﺪل از ﺣﺮوف اول اﻳﻦ ‪ ٣‬رﻧﮓ ﮔﺮﻓﺘﻪ ﺷﺪﻩ اﺳﺖ‪.‬‬ ‫داﻣﻨﻪ ي هﺮ آﺪام از اﻳﻦ ‪ ٣‬رﻧﮓ‪ ،‬ﻋﺪدي ﺑﻴﻦ ‪ 0‬ﺗﺎ ‪ 255‬اﺳﺖ‪.‬در اﻳﻦ ﻣﺪل‪ ٣ ،‬رﻧﮓ اﺻﻠﻲ وﺟﻮد دارد آﻪ ﺑﻘﻴﻪ رﻧﮓ هﺎ از اﻳﻦ ‪ ٣‬رﻧﮓ ﻣﺸﺘﻖ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬آﻪ ﺑﺮاي ﺗﻌﺮﻳﻒ رﻧـﮓ ار ﺁﻧﻬـﺎ اﺳـﺘﻔﺎدﻩ ﻣـﻲ ﺷـﻮد را ﺗﻮﺿـﻴﺢ‬ ‫ﻣﻲ دهﻢ‪.NET‬‬ ‫‪٥٥‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫)‪QBColor(color‬‬ ‫اﻳــﻦ ﺗــﺎﺑﻊ‪ ،‬ﺑــﺮاي ﺗﻮﻟﻴــﺪ ﺗﻌــﺪادي رﻧــﮓ از ﭘــﻴﺶ ﺗﻌﺮﻳــﻒ ﺷــﺪﻩ ﺑــﻪ آــﺎر ﻣــﻲ رود و ﻣﻘــﺪاري از ﻧــﻮع‬ ‫‪ Integer‬آﻪ ﻣﻌﺮف آﺪ رﻧﮓ اﻳﺠﺎد ﺷﺪﻩ اﺳﺖ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.blue‬‬ ‫رﻧﮓ هﺎ داراي ‪ ٤‬ﻣﺪل اﺻﻠﻲ هﺴﺘﻨﺪ‪.‬‬ ‫ﺗﻮﺟﻪ‪ :‬ﺗﻮاﺑـﻊ )(‪ LoadPicture‬و )(‪ SavePicture‬آـﻪ در ‪ VB.‬‬ ‫ﻣﺪﻟﻲ آﻪ ﻣﺎﻧﻴﺘﻮر و ﺗﻠﻮﻳﺰﻳﻮن ﺧﺎﻧﻪ ي ﻣﺎ ﺟﻬﺖ ﻧﻤﺎﻳﺶ رﻧﮓ هﺎ از ﺁن اﺳﺘﻔﺎدﻩ ﻣﻲ آﻨﺪ ﻣﺪل ‪RGB‬‬ ‫ﻧﺎم دارد‪ .NET‬‬ ‫وﺟﻮد ﻧﺪارﻧﺪ‪.‬‬ ‫ﻣﺪل‪ ،‬روش ﺗﻌﺮﻳﻒ ﻳﻚ رﻧﮓ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ‪.‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻗﺎدر ﺑﻪ ﺗﻮﻟﻴﺪ هﺮ ﻳﻚ از رﻧﮓ هﺎي ﻣﺪل ‪ RGB‬هﺴﺘﻴﻢ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،Color‬آﺪ رﻧﮕﻲ اﺳﺖ آﻪ ﺑﺎﻳﺪ ﺗﻮﻟﻴﺪ ﺷﻮد و ﻋﺪدي ﺑﻴﻦ ‪ 0‬ﺗﺎ ‪ 15‬اﺳﺖ‪.‬‬ ‫)‪RGB(red.‫ﺗﻮاﺑﻊ ﮔﺮاﻓﻴﻜﻲ‬ ‫)‪:(Graphics‬‬ ‫در اﻳﻦ ﻗﺴﻤﺖ‪ ،‬دو ﺗﺎﺑﻊ در ‪ VB.

‫در ﺟﺪول زﻳﺮ‪ ،‬آﺪ ﺗﻌﺪادي از رﻧﮓ هﺎي ﻣﺘﺪاول را در ﻣﺪل ‪ ،RGB‬ﻣﻼﺣﻈﻪ ﻣﻲ آﻨﻴﺪ‪:‬‬ ‫رﻧﮓ‬ ‫ﺳﻴﺎﻩ‬ ‫ﺁﺑﻲ‬ ‫ﺳﺒﺰ‬ ‫ﻻﺟﻮردي‬ ‫ﻗﺮﻣﺰ‬ ‫ارﻏﻮاﻧﻲ‬ ‫زرد‬ ‫ﺳﻔﻴﺪ‬ ‫آﺪ ﻣﻌﺎدل ﺗﻌﺪادي از رﻧﮓ هﺎي ﭘﺮآﺎرﺑﺮد در ﻣﺪل ‪RGB‬‬ ‫آﺪ ﭘﺎراﻣﺘﺮ ‪blue‬‬ ‫آﺪ ﭘﺎراﻣﺘﺮ ‪green‬‬ ‫آﺪ ﭘﺎراﻣﺘﺮ ‪red‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪255‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪255‬‬ ‫‪0‬‬ ‫‪255‬‬ ‫‪255‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪255‬‬ ‫‪255‬‬ ‫‪0‬‬ ‫‪255‬‬ ‫‪0‬‬ ‫‪255‬‬ ‫‪255‬‬ ‫‪255‬‬ ‫‪255‬‬ ‫‪255‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪ ،‬دﺳﺘﻮر زﻳﺮ‪ ،‬ﻳﻚ رﻧﮓ ﻗﺮﻣﺰ ﺧﺎﻟﺺ را اﻳﺠـﺎد و ﺑـﻪ ﭘـﺲ زﻣﻴﻨـﻪ ي ﻋﻨـﺼﺮ ‪،TextBox‬‬ ‫ﻧﺴﺒﺖ ﻣﻲ دهﺪ‪:‬‬ ‫)‪Text1.BackColor = RGB(255. 0‬‬ ‫ﻓﺮﻣﻮل ﺗﺒﺪﻳﻞ ﻣﻘﺪار ‪ RGB‬ﺑﻪ ﻣﻌﺎدل ‪:Long‬‬ ‫‪r + g * 256 + b * 256 ^ 2‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬ ‫‪٥٦‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ . 0.

‬‬ ‫دﺳﺘﻮرات زﻳﺮ‪ ،‬ﻣﻘﺪار ﻃﻮل و ﻋﺮض ﺗﻐﻴﻴﺮ ﻳﺎﻓﺘﻪ ي ﻓﺮم را در رﺟﻴﺴﺘﺮي ذﺧﻴﺮﻩ ﻣﻲ آﻨﻨﺪ‪:‬‬ ‫)‪SaveSetting(“MyApp”. “Startup”.‬‬ ‫ﻧﻜﺘﻪ‪ :‬ﻣﻨﺎﺳﺐ ﺗﺮﻳﻦ ﻣﻜﺎن ﺑﺮاي ﻧﻮﺷﺘﻦ اﻳﻦ آﺪهﺎ‪ ،‬زﻣﺎﻧﻲ اﺳﺖ آﻪ ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﭘﺎﻳـﺎن ﻣـﻲ ﭘـﺬﻳﺮد‬ ‫و ﻣﻨﺎﺳﺒﺘﺮﻳﻦ زﻣﺎن ﺟﻬﺖ ﻓﺮاﺧﻮاﻧﻲ ﺁﻧﻬﺎ‪ ،‬زﻣﺎﻧﻲ اﺳﺖ آﻪ ﺑﺮﻧﺎﻣﻪ ﺁﻏﺎز ﻣـﻲ ﺷـﻮد‪) .‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ رﺟﻴﺴﺘﺮي ﺳﺮ و آﺎر دارﻧﺪ‬ ‫)‪:(Registry‬‬ ‫در ‪ ،VB‬ﺗﻌﺪادي ﺗﺎﺑﻊ ﺑﺮاي ﺧﻮاﻧﺪن و ﻧﻮﺷﺘﻦ ﻣﻘﺎدﻳﺮ ﻣﺨﺘﻠﻒ در رﺟﻴﺴﺘﺮي وﻳﻨﺪوز وﺟﻮد دارد‪.‬‬ ‫)‪SaveSetting(appname. “Startup”.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻣﻲ ﺧﻮاهﻴﻢ ﻣﻘﺎدﻳﺮي را آﻪ در ﻣﺜﺎل ﺗﺎﺑﻊ )(‪ SaveSetting‬در رﺟﻴـﺴﺘﺮي ذﺧﻴـﺮﻩ‬ ‫آﺮدﻳﻢ‪ ،‬ﺣﺬف آﻨﻴﻢ‪ . “Width‬‬ ‫ﻣﻲ ﺗﻮاﻧﻴﺪ اﻳﻦ دﺳﺘﻮرات را در ﻳﻚ ﺧﻂ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺧﻼﺻﻪ آﻨﻴﺪ‪:‬‬ ‫)”‪DeleteSetting(“MyApp”.Width‬‬ ‫دﻗﺖ آﻨﻴﺪ آﻪ ﺑﻨﺪﻩ ﺟﻬﺖ راﺣﺘﻲ آﺎر‪ ،‬ﻣﻘﺪار ‪ ٣‬ﭘﺎراﻣﺘﺮ اول اﻳـﻦ دﺳـﺘﻮرات را ﻣﺘﻨﺎﺳـﺐ ﺑـﺎ ﻣﻘـﺪاري‬ ‫آﻪ ﻗﺮار اﺳﺖ ذﺧﻴﺮﻩ ﺷﻮد اﻧﺘﺨﺎب آﺮدم‪.‬‬ ‫ﻣﻘﺎدﻳﺮ در ﻳﻚ ﻣﺴﻴﺮ اﺻﻠﻲ‪ ،‬ﻳﻚ ﺷﺎﺧﻪ‪ ،‬ﻳﻚ زﻳﺮﺷﺎﺧﻪ و در ﻧﻬﺎﻳﺖ ﺑﻪ ﺻﻮرت ﻳﻚ ﻣﻘـﺪار رﺷـﺘﻪ اي‪،‬‬ ‫در زﻳﺮﺷﺎﺧﻪ ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ‪.‬ﻧﺎم اﻳﻦ ﺁرﮔﻮﻣﺎن ﻧﻴﺰ دﻟﺨﻮاﻩ اﺳﺖ‪. “Height‬‬ ‫)”‪DeleteSetting(“MyApp”.key‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ دﻗﻴﻘﺎ ﻋﻜﺲ ﺗﺎﺑﻊ )(‪ SaveSetting‬ﻋﻤﻞ آﺮدﻩ و ﻳﻚ ﻣﻘﺪار از زﻳﺮﺷﺎﺧﻪ ﻳﺎ آـﻞ زﻳﺮﺷـﺎﺧﻪ‬ ‫را از رﺟﻴﺴﺘﺮي ﺧﺬف ﻣﻲ آﻨﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ section‬ﻧﻴﺰ ﻧﺎم زﻳﺮ ﺷﺎﺧﻪ اي در ﺷﺎﺧﻪ ‪ appname‬اﺳﺖ آﻪ ﻣﻘﺎدﻳﺮ ﻣﺮﺑﻮط ﺑﻪ هـﻢ در‬ ‫اﻳﻦ زﻳﺮﺷﺎﺧﻪ ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ‪ .‬‬ ‫ﻧﻜﺘﻪ‪ :‬ﻣﺴﻴﺮ اﺻﻠﻲ ﺗﻮﺳﻂ ‪ VB‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد و ﻧﻴﺎزي ﺑﻪ وارد آﺮدن ﺁن ﻧﻴﺴﺖ‪.‬ﭘﺲ دﺳﺘﻮرات زﻳﺮ را ﻣﻲ ﻧﻮﻳﺴﻴﻢ‪:‬‬ ‫)”‪DeleteSetting(“MyApp”.Me. “Width”. key.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic. section.‬‬ ‫از اﻳﻦ ﺗﺎﺑﻊ ﻣﻌﻤﻮﻻ ﺑﺮاي ذﺧﻴﺮﻩ ﺗﻨﻈﻴﻤﺎت ﺑﺮﻧﺎﻣﻪ‪ ،‬اﺳﺘﻔﺎدﻩ ﻣﻲ ﺷﻮد‪.Me. “Startup”.‬‬ ‫اﮔﺮ ﻣﻘﺪار ‪ setting‬ﺑﻪ هﺮ دﻟﻴﻠﻲ ذﺧﻴﺮﻩ ﻧﺸﻮد‪ ،‬ﻳﻚ ﺧﻄﺎي زﻣﺎن اﺟﺮا در ﺑﺮﻧﺎﻣﻪ اﺗﻔﺎق ﻣﻲ اﻓﺘﺪ‪.NET‬‬ ‫‪٥٧‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،appname‬ﻧﺎم ﺷﺎﺧﻪ ﻳﺎ ﭘﻮﺷﻪ ي اﺻﻠﻲ اﺳﺖ آﻪ ﺗﻤﺎم زﻳﺮﭘﻮﺷﻪ هﺎ و ﻣﻘـﺎدﻳﺮ ﺁﻧﻬـﺎ در‬ ‫اﻳﻦ ﺷﺎﺧﻪ ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ‪ .‬ﺑـﺎ اﺳـﺘﻔﺎدﻩ از‬ ‫ﺗﺎﺑﻊ ‪ GetSetting‬آﻪ در اداﻣﻪ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻩ اﺳﺖ(‬ ‫)] ‪DeleteSetting(appname. “Height”.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻓﺮض آﻨﻴﺪ آﻪ ﻣﻘﺪار ﻃﻮل و ﻋﺮض ﻓﺮم ﺑﺮﻧﺎﻣﻪ ي ﻣﺎ‪ ،‬ﺗﻮﺳﻂ آـﺎرﺑﺮ در زﻣـﺎن اﺟـﺮاي‬ ‫ﺑﺮﻧﺎﻣﻪ ﺗﻐﻴﻴﺮ ﭘﻴﺪا آﻨﺪ و ﺑﺨﻮاهﻴﻢ دﻓﻌﻪ ي ﺑﻌﺪ آﻪ ﺑﺮﻧﺎﻣﻪ ﺗﻮﺳﻂ آﺎرﺑﺮ اﺟﺮا ﻣﻲ ﺷﻮد‪ ،‬ﻓﺮم ﺑـﺎ ﻃـﻮل‬ ‫و ﻋﺮض ﺟﺪﻳﺪ )ﻳﻌﻨﻲ هﻤﺎن اﻧﺪاز هﺎي ﺗﻐﻴﻴﺮ ﭘﻴﺪا آﺮدﻩ ﺗﻮﺳﻂ آﺎرﺑﺮ( ﻧﻤﺎﻳﺶ دادﻩ ﺷﻮد‪. Startup‬‬ ‫دﻗﺖ آﻨﻴﺪ اﮔﺮ ﻣﻘﺎدﻳﺮ دﻳﮕﺮي ﻧﻴﺰ در زﻳﺮﺷﺎﺧﻪ ي ‪ Startup‬وﺟﻮد داﺷـﺘﻪ ﺑﺎﺷـﻨﺪ‪ ،‬ﺁﻧﻬـﺎ ﻧﻴـﺰ ﺣـﺬف‬ ‫ﻣﻲ ﺷﻮﻧﺪ‪. setting‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﺟﻬﺖ ذﺧﻴﺮﻩ ﺳﺎزي ﻳـﻚ ﻣﻘـﺪار دﻟﺨـﻮاﻩ در رﺟﻴـﺴﺘﺮي ﻳـﺎ ﺑـﻪ هﻨﮕـﺎم آـﺮدن ﺁن ﻣﻘـﺪار از‬ ‫ﻃﺮﻳﻖ ﻧﻮﺷﺘﻦ ﺁن ﺑﺮ روي ﻣﻘﺪار ﻗﺒﻠﻲ‪ ،‬ﺑﻪ آﺎر ﻣﻲ رود‪. “Startup”.‬‬ ‫ﺁرﮔﻮﻣﺎن هﺎي اﻳﻦ ﺗﺎﺑﻊ‪ ،‬هﻤﺎن ﺁرﮔﻮﻣﺎن هﺎي ﺗﺎﺑﻊ )(‪ SaveSetting‬هﺴﺘﻨﺪ‪.‬‬ ‫اﮔـﺮ از ذآــﺮ ﺁرﮔﻮﻣـﺎن اﺧﺘﻴــﺎري ‪ key‬ﺧــﻮدداري ﺷـﻮد‪ ،‬ﺗﻤــﺎﻣﻲ ﻣﻘــﺎدﻳﺮ ﻣﻮﺟـﻮد در زﻳﺮﺷــﺎﺧﻪ ﺣــﺬف‬ ‫ﺧﻮاهﻨﺪ ﺷﺪ‪.section [.Height‬‬ ‫)‪SaveSetting(“MyApp”.‬ﻣﻲ ﺗﻮاﻧﻴﺪ هﺮ ﻧﺎم دﻟﺨﻮاهﻲ ﺑﻪ اﻳﻦ ﻧﺎم ﺑﺪهﻴﺪ اﻣﺎ ﺑﺮاي راﺣﺘﻲ آـﺎر‬ ‫ﺑﻬﺘﺮ اﺳﺖ ﻧﺎم ﺑﺮﻧﺎﻣﻪ ي ﺧﻮد را در اﻳﻦ ﺁرﮔﻮﻣﺎن ذآﺮ آﻨﻴﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،key‬ﻧﺎم ﻣﻘﺪار و ﺁرﮔﻮﻣﺎن ‪ setting‬ﻧﻴﺰ ﺧﻮد ﻣﻘﺪاري اﺳﺖ آﻪ ﺑﺎﻳﺪ ذﺧﻴﺮﻩ ﺷﻮد‪.

NET‬‬ ‫‪٥٨‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫)”‪AllSettings = GetAllSettings(“MyApp”.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻣﻲ ﺧﻮاهﻴﻢ ﻣﻘﺎدﻳﺮي را آﻪ در ﻣﺜﺎل ﺗﺎﺑﻊ )(‪ SaveSetting‬در رﺟﻴـﺴﺘﺮي ذﺧﻴـﺮﻩ‬ ‫آﺮدﻳﻢ‪ ،‬ﺑﻪ دﺳﺖ ﺁوردﻩ و ﻃﻮل و ﻋﺮض ﺟﺪﻳﺪ ﻓﺮم را در هﻨﮕﺎم اﺟﺮاي ﺑﺮﻧﺎﻣﻪ ﺗﻌﻴﻴﻦ آﻨﻴﻢ‪:‬‬ ‫)‪Me.‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻣﻘﺪار ذﺧﻴﺮﻩ ﺷﺪﻩ ي آﺎرﺑﺮ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.0) & “ = “ & AllSettings(i.‬‬ ‫‪ ٣‬ﺁرﮔﻮﻣﺎن اول اﻳﻦ ﺗﺎﺑﻊ هﻤﺎن ﭘﺎراﻣﺘﺮهﺎي ﺗﻮاﺑﻊ )(‪ SaveSetting‬و )(‪ DeleteSetting‬هـﺴﺘﻨﺪ‬ ‫آﻪ ﻣﺴﻴﺮ ذﺧﻴﺮﻩ دادﻩ در رﺟﻴﺴﺘﺮي را ﻣﺸﺨﺺ ﻣﻲ آﻨﻨﺪ‪.‫)] ‪GetSetting(appname. 1500‬‬ ‫در اﻳﻦ دﺳﺘﻮرات ﺣﺘﻤﺎ ﺑﺎﻳﺪ ﻣﻘﺪار ﺁرﮔﻮﻣﺎن ‪ default‬را ذآﺮ آﻨﻴﺪ ﭼـﻮن در ﺻـﻮرﺗﻲ آـﻪ ﻣﻘـﺪاري در‬ ‫رﺟﻴﺴﺘﺮي وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ‪ ،‬ﻓﺮم ﻣﻤﻜﻦ اﺳﺖ ﺑﺎ ﺳﺎﻳﺰي ﺑﺴﻴﺎر آﻮﭼﻚ ﻳﺎ ﺑـﺴﻴﺎر ﺑـﺰرگ ﻇـﺎهﺮ‬ ‫ﺷﻮد‪.‬‬ ‫دﺳــﺘﻮر زﻳــﺮ‪ ،‬ﺗﻤــﺎﻣﻲ ﻣﻘــﺎدﻳﺮ ﻣﻮﺟــﻮد در زﻳــﺮ ﺷــﺎﺧﻪ ي ‪ Startup‬از ﺷــﺎﺧﻪ ‪ MyApp‬را در ﺁراﻳــﻪ‬ ‫‪ AllSettings‬ﻗﺮار ﻣﻲ دهﺪ‪.‬‬ ‫ﻓﺮض ﻣﻲ آﻨﻴﻢ ﺁراﻳﻪ ‪ AllSettings‬ﺑﻪ ﻋﻨﻮان ﻳﻚ ﺁراﻳﻪ دو ﺑﻌﺪي ﻣﻌﺮﻓﻲ ﺷﺪﻩ اﺳﺖ‪.section.Height =GetSetting(“MyApp”.default‬‬ ‫وﻗﺘﻲ آﻪ ﻣﻘﺎدﻳﺮ در رﺟﻴﺴﺘﺮي ﻧﻮﺷﺘﻪ ﺷﺪ ﻃﺒﻌﺎ ﺑﺎﻳﺪ ﺁﻧﻬﺎ را ﺧﻮاﻧﺪ‪. “Width”.1‬‬ ‫‪Next‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.1‬ﺁراﻳﻪ‪ ،‬ﻣﻘﺪار ﺁن را ﻧﮕﻬﺪاري ﻣـﻲ‬ ‫آﻨﺪ و ﺑﻪ هﻤﻴﻦ ﺗﺮﺗﻴﺐ…‬ ‫ﻧﻜﺘﻪ‪ :‬ﺑﺮاي ﺁﮔﺎهﻲ از ﺗﻌﺪاد ﻣﻘﺎدﻳﺮ ذﺧﻴﺮﻩ ﺷﺪﻩ در ﺁراﻳﻪ ﻳﺎ ﺑﻪ ﻋﺒﺎرت ﺑﻬﺘﺮ ﺗﻌﺪاد ﻣﻘـﺎدﻳﺮ ﻣﻮﺟـﻮد در‬ ‫زﻳﺮﺷﺎﺧﻪ‪ ،‬از ﺧﺎﺻﻴﺖ ‪ Length‬ﺁراﻳﻪ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.0‬ﺁراﻳﻪ‪ ،‬ﻧﺎم اوﻟﻴﻦ ﻣﻘﺪار زﻳﺮﺷـﺎﺧﻪ و ﺧﺎﻧـﻪ ي )‪ (0. “Height”. 1000‬‬ ‫)‪Me. “Startup”.‬‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،default‬ﻣﻘﺪاري ﭘـﻴﺶ ﻓـﺮض اﺳـﺖ آـﻪ در ﺻـﻮرت ﻧﺒـﻮدن ﻣﻘـﺪاري در ﻣـﺴﻴﺮ‬ ‫ذآﺮﺷﺪﻩ‪ ،‬ﺗﻮﺳﻂ ﺗﺎﺑﻊ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد‪. “Startup”. “Startup‬‬ ‫ﺣﺎﻻ ﻣﻲ ﺗﻮاﻧﻴﻢ ﺑﺎ دﺳﺘﻮرات زﻳﺮ‪ ،‬ﺗﻤﺎﻣﻲ ﻣﻘﺎدﻳﺮ ﻣﻮﺟﻮد در زﻳﺮﺷﺎﺧﻪ را آـﻪ در ﺁراﻳـﻪ ذﺧﻴـﺮﻩ ﺷـﺪﻩ‬ ‫اﻧﺪ را ﺑﺒﻴﻨﻴﻢ‪:‬‬ ‫)‪For i =0 To AllSettings.‬‬ ‫ﺧﺎﻧﻪ ي )‪ (0.‬‬ ‫)‪GetAllSettings(appname.WriteLine(AllSettings(i.section‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻟﻴﺴﺘﻲ از ﺗﻤﺎﻣﻲ ﻣﻘﺎدﻳﺮ ﻣﻮﺟﻮد در زﻳﺮﺷـﺎﺧﻪ ﺗﻌﻴـﻴﻦ ﺷـﺪﻩ را ﺑـﺎ ﻗـﺮار دادن ﺁﻧﻬـﺎ در ﻳـﻚ‬ ‫ﺁراﻳﻪ ي دو ﺑﻌﺪي ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن هﺎي ‪ appname‬و ‪ section‬ﻗﺒﻼ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻧﺪ‪.‬‬ ‫ﺧﺎﻧﻪ ي )‪ (1.0‬ﺁراﻳﻪ‪ ،‬ﻧﺎم دوﻣﻴﻦ ﻣﻘﺪار زﻳﺮﺷﺎﺧﻪ و ﺧﺎﻧﻪ ي )‪ (1.GetUpperBound(0‬‬ ‫))‪Console.key [.1‬ﺁراﻳـﻪ‪ ،‬ﻣﻘـﺪار ﺁن را در ﺧـﻮد ﻧﮕـﻪ‬ ‫ﻣﻲ دارد‪.Width =GetSetting(“MyApp”.

‬‬ ‫اﻳﻦ ﻣﻘﺪار‪ ،‬ﻋﺪدي ﺑﺮ ﺣﺴﺐ ﻣﻴﻠﻲ ﺛﺎﻧﻴﻪ اﺳﺖ و هﺮ ‪ ١٠٠٠‬ﻣﻴﻠﻲ ﺛﺎﻧﻴﻪ‪ ١ ،‬ﺛﺎﻧﻴﻪ اﺳﺖ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،style‬وﺿﻌﻴﺖ ﻓﺮم ﺑﺮﻧﺎﻣﻪ اي آﻪ اﺟـﺮا ﺧﻮاهـﺪ ﺷـﺪ را ﻣﻌـﻴﻦ ﻣـﻲ آﻨـﺪ و ﻣـﻲ‬ ‫ﺗﻮاﻧﺪ ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ زﻳﺮ را ﺑﭙﺬﻳﺮد‪:‬‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ Style‬در ﺗﺎﺑﻊ )(‪Shell‬‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻣﻘﺪار‬ ‫ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت ﻣﺨﻔﻲ اﺟﺮا ﻣﻲ ﺷﻮد اﻣﺎ ﺑﻪ ﻋﻨـﻮان ﺑﺮﻧﺎﻣـﻪ ﻓﻌـﺎل‬ ‫‪Hide‬‬ ‫در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد‪.txt”.NormalFocus‬‬ ‫اﻳﻦ دﺳﺘﻮر‪ ،‬ﻓﺎﻳﻞ ‪ MyFile.‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮل و ﺑﺎ اﻧﺪازﻩ ﺧﻮدش اﺟﺮا ﻣـﻲ ﺷـﻮد اﻣـﺎ ﺑـﻪ‬ ‫‪NormalNoFocus‬‬ ‫ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌﺎل در ﻧﻈﺮ ﮔﺮﻓﺘـﻪ ﻧﻤـﻲ ﺷـﻮد و ﺑﺮﻧﺎﻣـﻪ اي آـﻪ ﺑـﻪ‬ ‫ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌﺎل اﺳﺖ‪ ،‬ﻓﻌﺎل ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ‪.‫ﺗﻮاﺑﻊ آﺎرﺑﺮدي‬ ‫)‪:(Application Collaboration‬‬ ‫)] ‪Shell(path_name [.exe C:\MyFile.txt‬را ﺑﻪ وﺳﻴﻠﻪ ﺑﺮﻧﺎﻣﻪ ‪ Notepad‬ﺑﺎز ﻣﻲ آﻨﺪ‪.‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت ﻣﻴﻨﻴﻤﺎﻳﺰ اﺟﺮا ﺧﻮاهﺪ ﺷﺪ و ﺑﻪ ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌـﺎل‬ ‫‪MinimizedFocus‬‬ ‫در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد‪.‬‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ‪ :‬اﻳﻦ ﺗﺎﺑﻊ ﺗﻨﻬﺎ ﻓﺎﻳﻞ هﺎي اﺟﺮاﻳﻲ را اﺟﺮا ﻣﻲ آﻨﺪ اﻣـﺎ ﻣـﻲ ﺗـﻮان ﺑـﺎ ﻧـﺴﺒﺖ دادن ﻧـﺎم و‬ ‫ﻣﺴﻴﺮ ﻓﺎﻳﻠﻲ دﻳﮕﺮ در اداﻣﻪ ﻧﺎم و ﻣﺴﻴﺮ ﻓﺎﻳﻞ اﺻﻠﻲ‪ ،‬در ﺻﻮرﺗﻲ آﻪ اﻳﻦ ﻓﺎﻳﻞ ﺑﺎ ﺑﺮﻧﺎﻣـﻪ ﻣـﻮرد ﻧﻈـﺮ‬ ‫ﻣﺎ ﻗﺎﺑﻞ اﺟﺮا ﺑﺎﺷﺪ‪ ،‬ﺁن را اﺟﺮا آﺮد ﻣﺜﻼ ﻳﻚ ﻓﺎﻳﻞ ﺑﺎ ﭘﺴﻮﻧﺪ ‪ TXT‬را ﻣـﻲ ﺗـﻮان ﺑـﺎ دﺳـﺘﻮر زﻳـﺮ اﺟـﺮا‬ ‫آﺮد‪:‬‬ ‫)‪NTXT=Shell(“notepad.style ][.‬‬ ‫اﻳﻦ ﭘﺎراﻣﺘﺮ‪ ،‬ﻣﻘﺪار ‪ True‬ﻳـﺎ ‪ False‬را ﻣـﻲ ﭘـﺬﻳﺮد آـﻪ ﺑـﻪ ﻃـﻮر ﭘـﻴﺶ ﻓـﺮض‪ False ،‬اﺳـﺖ ﻳﻌﻨـﻲ‬ ‫ﺑﺮﻧﺎﻣﻪ اي آﻪ ﻗﺮار اﺳﺖ اﺟﺮا ﺷﻮد ﺑﺎﻳﺪ ﺻﺒﺮ آﻨﺪ ﺗـﺎ ﺗﻤـﺎﻣﻲ دﺳـﺘﻮرات ﺑﻌـﺪ از ﺗـﺎﺑﻊ )(‪ shell‬اﺟـﺮا‬ ‫ﺷﻮﻧﺪ‪.‬‬ ‫ﺁﺧﺮﻳﻦ ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري آﻪ ‪ timeout‬ﻧﺎم دارد‪ ،‬ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ ﭘﺲ از ﭼﻨـﺪ ﺛﺎﻧﻴـﻪ ﺑﺮﻧﺎﻣـﻪ اي آـﻪ‬ ‫ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ ﺷﻮد ﺑﺎﻳﺪ اﺟﺮا ﺷﻮد‪. AppWinStyle.‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت ﺗﻤﺎم ﺻـﻔﺤﻪ اﺟـﺮا ﻣـﻲ ﺷـﻮد و ﺑـﻪ ﻋﻨـﻮان ﺑﺮﻧﺎﻣـﻪ‬ ‫‪MaximizedFocus‬‬ ‫ﻓﻌﺎل در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد‪.‬‬ ‫در ﺻﻮرﺗﻲ آﻪ اﻳﻦ ﺗﺎﺑﻊ آﺎر ﺧﻮد را ﺑﺎ ﻣﻮﻓﻘﻴﺖ اﻧﺠﺎم دهﺪ‪ ،‬هﻨﺪل ﺑﺮﻧﺎﻣﻪ ي اﺟﺮا ﺷﺪﻩ را آﻪ ﺗﻮﺳـﻂ‬ ‫ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ در ﻏﻴﺮ اﻳﻨﺼﻮرت‪ ،‬ﻣﻘﺪار ﺻﻔﺮ را ﺑﺮﮔـﺸﺖ ﻣـﻲ‬ ‫دهﺪ‪.NET‬‬ ‫‪٥٩‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮل و ﺑـﺎ اﻧـﺪازﻩ ﺧـﻮدش اﺟـﺮا ﻣـﻲ ﺷـﻮد و ﺑـﻪ‬ ‫‪NormalFocus‬‬ ‫ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌﺎل در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد‪.wait ][.‬‬ ‫‪ MinimizedNoFocus‬ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت ﻣﻴﻨﻴﻤﺎﻳﺰ اﺟﺮا ﻣﻲ ﺷﻮد اﻣﺎ ﺑﻪ ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌـﺎل‬ ‫در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻧﻤﻲ ﺷﻮد و ﺑﺮﻧﺎﻣـﻪ اي آـﻪ ﺑـﻪ ﻋﻨـﻮان ﺑﺮﻧﺎﻣـﻪ ﻓﻌـﺎل‬ ‫اﺳﺖ‪ ،‬ﻓﻌﺎل ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ wait‬ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ ﺁﻳﺎ ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﺑﺮاي اﺟﺮاي آﺎﻣﻞ ﺑﺮﻧﺎﻣﻪ اي آﻪ ﻓﺮاﺧـﻮاﻧﻲ‬ ‫ﺧﻮاهﺪ ﺷﺪ ﺻﺒﺮ آﻨﺪ ﻳﻌﻨﻲ دﺳﺘﻮرات ﺑﻌـﺪ از ﺗـﺎﺑﻊ )(‪ ،Shell‬ﭘـﺲ از ﻓﺮاﺧـﻮاﻧﻲ ﺑﺮﻧﺎﻣـﻪ ﻣـﻮرد ﻧﻈـﺮ‬ ‫اﺟﺮا ﺷﻮﻧﺪ ﻳﺎ ﺑﻼﻓﺎﺻﻠﻪ‪.‬‬ ‫ﺑﻪ ﻋﺒﺎرت ﺳﺎدﻩ ﺗﺮ‪ ،‬ﺗﻌﻴﻴﻦ ﻣﻲ آﻨـﺪ آـﻪ ﻗﺒـﻞ از اﺟـﺮاي ﺗﻤـﺎﻣﻲ دﺳـﺘﻮرات ﺑﻌـﺪ از ﺗـﺎﺑﻊ )(‪،Shell‬‬ ‫ﺑﺮﻧﺎﻣﻪ اﺟﺮا ﺷﻮد ﻳﺎ در هﻤﺎن زﻣﺎن ﻓﺮاﺧﻮاﻧﻲ‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،path_name‬ﻣﺴﻴﺮ و ﻧﺎم ﻓﺎﻳﻠﻲ اﺳﺖ آﻪ ﻣﻲ ﺧﻮاهﻴﻢ اﺟﺮا ﺷﻮد‪ .‬اﮔـﺮ ﻓﺎﻳـﻞ اﺟﺮاﻳـﻲ‬ ‫ﻧﻴﺎز ﺑﻪ ﺁرﮔﻮﻣﺎن هﺎﻳﻲ هﻤﺎﻧﻨﺪ ‪ command‬هﺎي ﻣﺨﺼﻮص ﺧﻮد داﺷﺖ‪ ،‬ﻣﻲ ﺗﻮان ﻧـﺎم ﺁﻧﻬـﺎ را ﻧﻴـﺰ‬ ‫در اداﻣﻪ ﻣﺴﻴﺮ ﻓﺎﻳﻞ ذآﺮ آﺮد آﻪ اﻳﻦ ﻣﻮرد ﻣﻌﻤﻮﻻ ﻧﺪرﺗﺎ وﺟﻮد دارد‪.timeout‬‬ ‫ﺑﺎ اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻗﺎدر ﺑﻪ اﺟﺮاي ﻳﻚ ﺑﺮﻧﺎﻣﻪ دﻳﮕﺮ از درون ﺑﺮﻧﺎﻣﻪ ي ﺧﻮد هﺴﺘﻴﺪ‪.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.

‬‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ wait‬ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ ﺁﻳﺎ ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﺑﺎﻳـﺪ ﺑـﻪ ﻋﻨـﻮان ﺑﺮﻧﺎﻣـﻪ ﻓﻌـﺎل ﺑﺎﺷـﺪ ﺗـﺎ‬ ‫ﺑﺘﻮاﻧﺪ ﺑﺮﻧﺎﻣﻪ دﻳﮕﺮي را ﺑﺎ اﻳﻦ ﺗﺎﺑﻊ ﻓﻌﺎل آﻨﺪ ﻳﺎ ﺧﻴﺮ‪.‬‬ ‫ﻣﻘﺎﻳﺴﻪ ي رﺷﺘﻪ اي ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ ﻃﻮر ﻣﻌﻤﻮل ﻳﺎ ﺑﺎ در ﻧﻈﺮ ﮔﺮﻓﺘﻦ ﺑـﺰرگ ﻳـﺎ آﻮﭼـﻚ ﺑـﻮدن ﺣـﺮوف‬ ‫اﻧﺠﺎم ﺷﻮد‪.NET‬‬ ‫‪٦٠‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫)] ‪AppActivate(title [.‬ﻣﻘﺪار ﭘﻴﺶ ﻓﺮض‪ False ،‬اﺳﺖ ﻳﻌﻨـﻲ ﺣﺘـﻲ در‬ ‫ﺻﻮرت ﻓﻌﺎل ﻧﺒﻮدن ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﻧﻴﺰ‪ ،‬ﺑﺮﻧﺎﻣﻪ درﺧﻮاﺳﺘﻲ ﺑﻪ ﺳﺮﻋﺖ ﻓﻌﺎل ﻣﻲ ﺷﻮد‪.NET‬وﺟﻮد ﻧﺪارد‪.‬‬ ‫دﺳﺘﻮرات اﺧﺘﻴﺎري )‪:(Option Statements‬‬ ‫دﺳﺘﻮرات ‪ Option‬ﻳﺎ اﺧﺘﻴﺎري‪ ،‬ﺳﻬﻮﻟﺖ آﺎر در آﺪﻧﻮﻳﺴﻲ را ﺑﺮاي ﺷﻤﺎ ﻓﺮاهﻢ ﻣﻲ آﻨﻨﺪ‪.‬‬ ‫ﻣﻘﺎﻳﺴﻪ رﺷﺘﻪ اي ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ ﻳﻜﻲ از دو ﺷﻜﻞ زﻳﺮ ﺻﻮرت ﭘﺬﻳﺮد‪:‬‬ ‫‪ :Option Compare Binary‬در اﻳــﻦ ﻧــﻮع ﻣﻘﺎﻳــﺴﻪ آــﻪ ﺑــﻪ ﺻــﻮرت ﺑــﺎﻳﻨﺮي اﻧﺠــﺎم ﻣــﻲ ﺷــﻮد‪،‬‬ ‫آﺎراآﺘﺮهﺎي ﺑﺰرگ ﺑﺮ آﺎراآﺘﺮهﺎي آﻮﭼﻚ ارﺟﻌﻴﺖ دارﻧـﺪ و آﺎراآﺘﺮهـﺎي ‪ Symbol‬ﻳـﺎ ﻧﻤـﺎد در اﻧﺘﻬـﺎ‬ ‫ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ‪ .exe”.‬ﻣﺜﻼ ﺑﻪ ﺷﻜﻞ زﻳﺮ‪:‬‬ ‫^‪A < B < C… < Z < a < b < c… < z < A’ < A^ < a’ < a‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬‬ ‫در ﺻﻮرﺗﻲ آﻪ ‪ True‬ﺑﺎﺷﺪ‪ ،‬ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﺑﺎﻳﺪ ﺻﺒﺮ آﻨﺪ ﺗﺎ ﻓﻌـﺎل ﺷـﻮد ﻳـﺎ اﺻـﻄﻼﺣﺎ ﻓﻮآـﺎس ﺑـﻪ ﺁن‬ ‫اﻧﺘﻘﺎل ﭘﻴﺪا آﻨﺪ ﺗﺎ ﺑﺘﻮاﻧﺪ ﺑﺮﻧﺎﻣﻪ دﻳﮕﺮي را ﻓﻌﺎل آﻨﺪ‪.‬‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ‪ :‬ﺗﺎﺑﻊ )(‪ SendKeys‬در ‪ VB.‬ﻣﺜﻼ‪“Untitled – Notepad" :‬‬ ‫در اﻳﻦ ﺁرﮔﻮﻣﺎن هﻤﭽﻨﻴﻦ ﺑﺎ ذآﺮ آﺮدن ﻣﻘﺪاري آﻪ ﺗـﺎﺑﻊ )(‪ Shell‬در ﻣﺘﻐﻴـﺮ ﻓﺮاﺧـﻮاﻧﻲ آﻨﻨـﺪﻩ ﺧـﻮد‬ ‫ﻗﺮار ﻣﻲ دهﺪ‪ ،‬ﻗﺎدر ﺑﻪ ﻓﻌﺎل آﺮدن ﺑﺮﻧﺎﻣﻪ هﺴﺘﻴﺪ‪ .‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪ ،‬ﺑﺮاي اﺟﺮاي ﺑﺮﻧﺎﻣﻪ ‪ Notepad‬وﻳﻨﺪوز از دﺳﺘﻮر زﻳﺮ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪:‬‬ ‫)‪NPAD = Shell(“notepad.‬اﻳﻦ دﺳﺘﻮرات را در زﻳﺮ ﻣﺸﺎهﺪﻩ ﻣﻲ آﻨﻴﺪ‪:‬‬ ‫‪Option Compare‬‬ ‫اﻳﻦ دﺳﺘﻮر ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ ‪ VB‬ﭼﮕﻮﻧﻪ ﻋﻤﻠﻴﺎت ﻣﻘﺎﻳﺴﻪ اي رﺷﺘﻪ هﺎ را اﻧﺠﺎم دهﺪ‪.‬‬ ‫ﺗﻮﺟﻪ‪ :‬اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﻣﻴﻨﻴﻤﺎﻳﺰ ﺑﻮدن ﻳﺎ اﻧﺪازﻩ ي ﭘﻨﺠﺮﻩ هﺎ آﺎري ﻧﺪارد و ﻣﺜﻼ اﮔـﺮ ﺑﺮﻧﺎﻣـﻪ اي ﻣﻴﻨﻴﻤـﺎﻳﺰ‬ ‫ﺑﺎﺷﺪ‪ ،‬ﺁن را در هﻤﺎن ﺣﺎﻟﺖ ﻣﻴﻨﻴﻤﺎﻳﺰ ﺑﻪ ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌﺎل در ﻧﻈﺮ ﻣﻲ ﮔﻴﺮد‪.‬‬ ‫اﻳﻦ دﺳﺘﻮرات در اﺑﺘﺪاي آﺪ ﻓﺮم ﻳﺎ ﻣـﺎژول ﻧﻮﺷـﺘﻪ ﻣـﻲ ﺷـﻮﻧﺪ و در ﺗﻤـﺎم ﺁن ﻓـﺮم ﻳـﺎ ﻣـﺎژول ﻗﺎﺑـﻞ‬ ‫دﺳﺘﺮﺳﻲ هﺴﺘﻨﺪ‪ .‫ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﻣﻘﺪار اﻳﻦ ﺁرﮔﻮﻣﺎن‪ -1 ،‬اﺳﺖ ﻳﻌﻨﻲ ﺑﺪون وﻗﻔـﻪ و ﺑﻼﻓﺎﺻـﻠﻪ ﭘـﺲ از ﻓﺮاﺧـﻮاﻧﻲ‬ ‫اﺟﺮا ﻣﻲ ﺷﻮد‪.wait‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ )آﻪ ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ ﻧﺪارد( ﺑﻪ ﺷﻤﺎ اﺟﺎزﻩ ﻣـﻲ دهـﺪ ﺑﺮﻧﺎﻣـﻪ اي را آـﻪ ﻗـﺒﻼ ﺗﻮﺳـﻂ ﺗـﺎﺑﻊ‬ ‫)(‪ Shell‬ﻓﺮاﺧﻮاﻧﻲ و اﺟﺮا آﺮدﻩ اﻳﺪ‪ ،‬ﺑﻪ ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌﺎل )ﭘﻨﺠﺮﻩ ﻓﻌﺎل( ﺳﻴﺴﺘﻢ ﻋﺎﻣـﻞ ﻣﻌﺮﻓـﻲ‬ ‫آﻨﻴﺪ‪.‬در اﻳﻦ ﺣﺎﻟﺖ اﮔﺮ ﻧﺎم ﻧﻮار ﻋﻨﻮان را در ﺗـﺎﺑﻊ )(‪ AppActivate‬ذآـﺮ آﻨﻴـﺪ‪،‬‬ ‫ﺁن ﻳﻜﻲ آﻪ ﺁﺧﺮ اﺟﺮا ﺷﺪﻩ اﺳﺖ ﺑﻪ ﻋﻨﻮان ﭘﻨﺠﺮﻩ ﻓﻌﺎل در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد آـﻪ ﻣﻤﻜـﻦ اﺳـﺖ‬ ‫دﻟﺨﻮاﻩ ﺷﻤﺎ ﻧﺒﺎﺷﺪ‪.NormalFocus‬‬ ‫ﺗﻮﺟﻪ‪ :‬ﺑﺮاي اﺟﺮاي ﺑﺮﻧﺎﻣﻪ هﺎﻳﻲ آﻪ در ﭘﻮﺷﻪ اﺻﻠﻲ وﻳﻨﺪوز هـﺴﺘﻨﺪ‪ ،‬ﻧﻴـﺎزي ﺑـﻪ ذآـﺮ ﻣـﺴﻴﺮ ﺁﻧﻬـﺎ‬ ‫ﻧﻴﺴﺖ و ﺗﻨﻬﺎ ﺁوردن ﻧﺎم‪ ،‬آﻔﺎﻳﺖ ﻣﻲ آﻨﺪ‪.‬ﻣﺜﻼ ﻓﺮض آﻨﻴﺪ آﻪ ﺑﺮﻧﺎﻣﻪ ‪ Notepad‬را ‪ ٢‬ﺑﺎر اﺟﺮا آﺮدﻩ اﻳـﺪ و ﻋﻨـﻮان ﻧـﻮار هـﺮ دو ﭘﻨﭽـﺮﻩ‬ ‫‪ ،Notepad‬ﻳﻜﻲ اﺳﺖ‪ .‬‬ ‫در ﺁرﮔﻮﻣﺎن ‪ ،title‬آﻪ ﻣﻘﺪاري از ﻧﻮع رﺷﺘﻪ اي اﺳﺖ ﺑﺎﻳﺪ ﻧﺎم ﻧﻮار ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ اي آﻪ ﻗـﺼﺪ ﻓﻌـﺎل‬ ‫ﺷﺪن ﺁن را دارﻳﺪ ذآﺮ آﻨﻴﺪ‪ .‬‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ‪ :‬هﻤﻴﺸﻪ ﺳﻌﻲ آﻨﻴﺪ اﺑﺘﺪا ﺑﺮﻧﺎﻣﻪ ﻣﻮرد ﻧﻈﺮ را ﺑﺎ ﺗﺎﺑﻊ )(‪ Shell‬اﺟـﺮا و ﺳـﭙﺲ ﻣﺘﻐﻴـﺮي‬ ‫آﻪ ﺗﺎﺑﻊ )(‪ Shell‬را در ﺁن ﻗﺮار دادﻩ اﻳﺪ در ﺁرﮔﻮﻣﺎن ‪ title‬اﻳﻦ ﺗﺎﺑﻊ ﻗﺮار دادﻩ و اﻗﺪام ﺑﻪ ﻓﻌـﺎل آـﺮدن‬ ‫ﺁن آﻨﻴﺪ‪ .‬‬ ‫اﻳﻦ ﭘﺎراﻣﺘﺮ‪ ،‬ﻣﻘﺪار ‪ True‬ﻳﺎ ‪ False‬را ﻣﻲ ﭘﺬﻳﺮد‪ .‬ﻣﺜﻼ در ﺁﺧﺮﻳﻦ ﻣﺜـﺎل ﺗﻮﺿـﻴﺤﺎت ﺗـﺎﺑﻊ )(‪،Shell‬‬ ‫ﻣﻲ ﺗﻮاﻧﻴﺪ ﻧﺎم ﻣﺘﻐﻴﺮ ‪ NPAD‬را در ﺁرﮔﻮﻣﺎن ‪ title‬اﻳﻦ ﺗﺎﺑﻊ ذآﺮ آﻨﻴﺪ‪. AppWinStyle.

‬‬ ‫دﺳﺘﻮرات زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫‪Dim MyVar‬‬ ‫”‪MyVar=”Hello World‬‬ ‫در دﺳﺘﻮرات ﻓﻮق اﺑﺘﺪا ﻳﻚ ﻣﺘﻐﻴـﺮ ﺑـﺪون ﻧـﻮع ﺗﻌﺮﻳـﻒ ﻣـﻲ ﺷـﻮد آـﻪ ﺑـﻪ ﻃـﻮر ﭘـﻴﺶ ﻓـﺮض از ﻧـﻮع‬ ‫‪ Object‬در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد و ﺳﭙﺲ در هﻨﮕﺎم ﻣﻘﺪاردهﻲ ﺑﻪ ﺁن‪ VB ،‬ﺑﻪ ﻃـﻮر ﺧﻮدآـﺎر ﻧـﻮع‬ ‫ﻣﻘﺪار ﻧﺴﺒﺖ دادﻩ ﺷﺪﻩ را ﺗﺸﺨﻴﺺ و ﺁن را ﺗﺒﺪﻳﻞ ﺑﻪ ﺁن ﻧﻮع ﻣـﻲ آﻨـﺪ آـﻪ در ﻣﺜـﺎل ﻓـﻮق از ﻧـﻮع‬ ‫‪ String‬در ﻧﻈﺮ ﻣﻲ ﮔﻴﺮد‪.‬‬ ‫در اﻳﻦ ﺣﺎﻟﺖ‪ ،‬در زﻣﺎن اﺟﺮاي ﺑﺮﻧﺎﻣﻪ آﺎﻣﭙﺎﻳﻠﺮ ‪ VB‬ﺗﻤـﺎﻣﻲ ﻣﺘﻐﻴﺮهـﺎ را از ﻟﺤـﺎظ ﺗﻌﺮﻳـﻒ ﺷـﺪن ﭼـﻚ‬ ‫ﻣﻲ آﻨﺪ و در ﺻﻮرﺗﻲ آﻪ هﺮ ﻳﻚ ار ﺁﻧﻬﺎ ﺗﻌﺮﻳﻒ ﻧﺸﺪﻩ ﺑﺎﺷﻨﺪ‪ ،‬ﺑﻪ ﺷﻤﺎ اﺧﻄﺎر ﻣﻲ دهﺪ‪.‬در ‪ VB.‫‪ :Option Compare Text‬در اﻳﻦ ﻧﻮع ﻣﻘﺎﻳﺴﻪ‪ ،‬ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ ﺑـﺎ ﺗﻮﺟـﻪ ﺑـﻪ ﺑـﺰرگ و آﻮﭼـﻚ ﺑـﻮدن‬ ‫ﺣﺮوف اﻧﺠﺎم ﻣﻲ ﺷﻮد‪ .0‬از ﻧﻮع ‪ Variant‬در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﺪ(‬ ‫‪Option Strict‬‬ ‫هﻤﺎن ﻃﻮر آﻪ اﺷﺎرﻩ ﺷﺪ در ﺻﻮرﺗﻲ آﻪ ﻧﻮع ﻣﺘﻐﻴﺮي در ‪ VB.NET‬ﻧﻮع ﻣﺘﻐﻴﺮ ﺗﻌﺮﻳﻒ ﻧﺸﻮد ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض از ﻧـﻮع ‪ Object‬در‬ ‫ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد‪) .‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬‬ ‫ﻣﻲ ﺗﻮان ﺑﺎ اﺳﺘﻔﺎدﻩ از اﻳﻦ دﺳﺘﻮر ﺑﻪ آﺎﻣﭙﺎﻳﻠﺮ وﻳﮋوال ﺑﻴﺴﻴﻚ ﮔﻔﺖ آﻪ از ﺗﻌﺮﻳـﻒ ﻧﻜـﺮدن ﻣﺘﻐﻴﺮهـﺎ‬ ‫در ﻃﻮل ﻓﺮم ﻳﺎ ﻣﺎژوﻟﻲ آﻪ اي دﺳﺘﻮر ﻗﺮار ﻣﻲ ﮔﻴﺮد‪ ،‬ﺟﻠﻮﮔﻴﺮي آﻨﺪ‪.‬‬ ‫ﺗﻮﺟﻪ‪ :‬در ﺻﻮرﺗﻲ آﻪ در ‪ ،VB.‬اﻳﻦ ﻧﻮع ﻣﻘﺎﻳﺴﻪ‪ ،‬ﻣﻘﺎﻳﺴﻪ ﭘﻴﺶ ﻓﺮض رﺷﺘﻪ هﺎ اﺳﺖ‪ .‬ﻣﺜﻼ‪:‬‬ ‫‪A=a < A'=a' < B=b‬‬ ‫‪Option Explicit‬‬ ‫هﻤﺎن ﻃﻮر آﻪ ﻣﻲ داﻧﻴﺪ‪ ،‬در ‪ VB‬ﻣﻲ ﺗﻮان ﻳﻚ ﻣﺘﻐﻴﺮ را ﺑﺪون ﺗﻌﺮﻳﻒ آﺮدن ﺁن ﺑﻪ آﺎر ﺑﺮد‪.6.NET‬ذآﺮ ﻧﺸﻮد‪ ،‬ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض‬ ‫از ﻧﻮع ‪ Object‬در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد و در هﻨﮕﺎم ﻣﻘﺪاردهﻲ ﺑـﻪ ﺁن ﻣﺘﻐﻴـﺮ‪ ،‬ﻧـﻮع ﺁن ﺑـﻪ ﺻـﻮرت‬ ‫ﺧﻮدآﺎر ﺗﻮﺳﻂ ‪ VB‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد‪.NET‬‬ ‫‪٦١‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫ﭼﻨﺎﻧﭽﻪ ﻣﺎﻳﻞ هﺴﺘﻴﺪ آﻪ ﻋﻤﻞ ﺗﺒﺪﻳﻞ ﺧﻮآﺎر ﻧﻮع ﻣﺘﻐﻴﺮ ﺗﻌﺮﻳـﻒ ﻧـﺸﺪﻩ ﺗﻮﺳـﻂ ‪ VB‬اﻧﺠـﺎم ﻧـﺸﻮد و‬ ‫هﻤــﺎن ﻣﻘــﺪار ‪ Object‬در ﻧﻈــﺮ ﮔﺮﻓﺘــﻪ ﺷــﻮد‪ ،‬دﺳــﺘﻮر ‪ Option Strict‬را در اوﻟــﻴﻦ ﺧــﻂ آــﺪ ﻓــﺮم‬ ‫ﺑﻨﻮﻳﺴﻴﺪ‪.NET‬ﺑﻪ ﻃﻮر ﺧﻮدآﺎر در ﺗﻤﺎﻣﻲ ﻓﺮم هﺎ و ﻣﺎژول هﺎي ﺑﺮﻧﺎﻣﻪ اﻳﻦ دﺳﺘﻮر را ﻓﻌﺎل آﻨﻴﺪ‪.‬‬ ‫ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺎ ﻓﻌﺎل آﺮدن اﻳﻦ ﮔﺰﻳﻨﻪ در ﺳﺮﺑﺮگ ‪ Build‬از ﻗﺴﻤﺖ ‪ Project Property Pages‬در‬ ‫‪ ،VB.

“two”.‫ﺗﻮاﺑﻊ ﻣﺘﻔﺮﻗﻪ‬ ‫)‪:(Miscellaneous‬‬ ‫ﺗﻮاﺑﻌﻲ هﺴﺘﻨﺪ آﻪ ﻧﻤﻲ ﺗﻮان ﺁﻧﻬﺎ را در هﻴﭻ ﮔﺮوهﻲ دﺳﺘﻪ ﺑﻨﺪي آﺮد‪.‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻣﻘﺪاري را از ﻳﻚ ﺳﺮي ﺁرﮔﻮﻣﺎن‪ ،‬اﻧﺘﺨﺎب و ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪. “nine‬‬ ‫‪End Function‬‬ ‫دﺳﺘﻮر زﻳﺮ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ ﺑﺎﻻ‪ ،‬ﻣﻘﺪار ﺣﺮﻓﻲ ﻣﻌﺎدل ﻋـﺪد ‪ ٨‬را ﺑﺮﮔﺮداﻧـﺪﻩ و ﺑـﺎ اﺳـﺘﻔﺎدﻩ از ﺗـﺎﺑﻊ‬ ‫)(‪ MsgBox‬ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪:‬‬ ‫))‪MsgBox(IntToString(8‬‬ ‫ﺗﻮﺟﻪ‪ :‬در ﺻﻮرﺗﻲ آﻪ ﻣﻘﺪار ﺁرﮔﻮﻣﺎن ‪ index‬از ‪ ١‬آﻤﺘﺮ ﻳﺎ ﻣﻘﺪار ﺁن از ﺗﻌﺪاد ﺁرﮔﻮﻣﺎن هـﺎي ‪choice‬‬ ‫ﺑﻴﺸﺘﺮ ﺑﺎﺷﺪ‪ ،‬ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﻣﻘﺪار ‪ Null‬ﺧﻮاهﺪ ﺑﻮد‪.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،index‬ﻳﻚ ﻣﻘـﺪار ﻋـﺪدي ﺑـﻴﻦ ‪ ١‬ﺗـﺎ ﺗﻌـﺪاد ﺁرﮔﻮﻣـﺎن هـﺎي ‪ Choice‬اﺳـﺖ آـﻪ ﻧﻤﺎﻳـﺎﻧﮕﺮ‬ ‫ﺷﻤﺎرﻩ ﺁرﮔﻮﻣﺎﻧﻲ اﺳﺖ آﻪ ﻣﻲ ﺧﻮاهﻴﻢ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد‪.truepart. “five”.choice1 [. “six”.falsepart‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﺷﻜﻞ ﺳﺎدﻩ ﺗﺮ اﺳﺘﻔﺎدﻩ از ﺳﺎﺧﺘﺎر ﺗﺼﻤﻴﻢ ﮔﻴﺮي ‪ If Then Else‬اﺳﺖ‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜـﺎل‪ ،‬اﮔـﺮ ﻣﻘـﺪار ‪ ١ ،index‬ﺑﺎﺷـﺪ ﻣﻘـﺪار ﺑﺮﮔـﺸﺘﻲ‪ ،‬ﻣﻘـﺪار ﺁرﮔﻮﻣـﺎن ‪ choice1‬و اﮔـﺮ‬ ‫‪ ٢ ،index‬ﺑﺎﺷﺪ‪ ،‬ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ ﺗﺎﺑﻊ‪ ،‬ﻣﻘﺪار ﺁرﮔﻮﻣﺎن ‪ choice2‬و ﺑﻪ هﻤﻴﻦ ﺗﺮﺗﻴﺐ ﺧﻮاهﺪ ﺑﻮد‪.‬‬ ‫ﻣﺜﻼ ﻳﻜﻲ از آﺎرﺑﺮدهﺎي اﻳﻦ ﺗﺎﺑﻊ ﺑﺮاي ﺑﺮﮔﺸﺖ ﻣﻌﺎدل ﺣﺮﻓﻲ اﻋﺪاد ﺗﻚ رﻗﻤﻲ اﺳﺖ‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪ ،‬ﺗﺎﺑﻊ زﻳﺮ آﻪ )(‪ IntToString‬ﻧﺎم دارد‪ ،‬ﻧﺎم ﻣﻌﺎدل ﻋﺪدي آﻪ ﺑﻪ ﺁن دادﻩ ﻣﻲ ﺷـﻮد‬ ‫را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪:‬‬ ‫‪Function IntToString(int As Integer)As String‬‬ ‫_ ‪IntToString =Choose (int + 1. “one”. “zero”. “seven”.NET‬‬ ‫‪٦٢‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫در ﻣﺜﺎل زﻳﺮ‪ ،‬ﭼﻨﺎﻧﭽﻪ ﻣﻘﺪار ‪ A‬از ‪ B‬آﻮﭼﻜﺘﺮ ﺑﺎﺷﺪ‪ A ،‬در ‪ Min‬وﮔﺮﻧﻪ ‪ B‬در ‪ Min‬ﻗﺮار ﻣﻲ ﮔﻴﺮد‪:‬‬ ‫)‪Min=Iif(A < B.choice2.‬‬ ‫اﻳﻦ ﺗﻮاﺑﻊ در اﻳﻦ ﻗﺴﻤﺖ ﻣﻮرد ﺑﺤﺚ ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ‪. A. “eight”.‬‬ ‫)”‪“four”.‬‬ ‫اﮔــﺮ ﻋﺒــﺎرت ﺷــﺮﻃﻲ ﻣﻮﺟــﻮد در ‪ ،expression‬ﺻــﺤﻴﺢ ﺑﺎﺷــﺪ‪ ،‬ﻋﺒــﺎرت ‪ truepart‬وﮔﺮﻧــﻪ ﻋﺒــﺎرت‬ ‫‪ falsepart‬اﺟﺮا ﺧﻮاهﺪ ﺷﺪ‪.‬‬ ‫)]‪Choose(index.‬‬ ‫ﺁرﮔﻮﻣﺎن هـﺎي ‪ choice2 ،choice1‬و…‪ ،‬ﻟﻴـﺴﺘﻲ از ﺁرﮔﻮﻣـﺎن هـﺎﻳﻲ هـﺴﺘﻨﺪ آـﻪ ﻣـﻲ ﺧـﻮاهﻴﻢ‬ ‫ﻣﻘﺪاري را از ﺁﻧﻬﺎ اﻧﺘﺨﺎب و ﺑﺮﮔﺸﺖ دهﻴﻢ‪.‬‬ ‫)‪IIf(expression..‬‬ ‫ﻣﻌﺎدل ﺳﺎﺧﺘﺎر ‪ If Then Else‬اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺖ‪:‬‬ ‫‪If expression Then‬‬ ‫‪result =truepart‬‬ ‫‪Else‬‬ ‫‪result =falsepart‬‬ ‫‪End If‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻳﻚ ﻋﺒﺎرت ﺷﺮﻃﻲ اﺳﺖ آﻪ درﺳﺖ ﻳﺎ ﻏﻠﻂ ﺑﻮدن ﺁن ﺑﺎﻳﺪ ﭼﻚ ﺷﻮد‪. “three” ... B‬‬ ‫دﺳﺘﻮر زﻳﺮ ﻣﻌﺎدل دﺳﺘﻮر ﻓﻮق اﺳﺖ‪:‬‬ ‫‪If A < B Then‬‬ ‫‪Min=A‬‬ ‫‪Else‬‬ ‫‪Min=B‬‬ ‫‪End If‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.

value2. 1.‬‬ ‫ﻧﻜﺘﻪ‪ :‬در ﺻﻮرﺗﻲ آﻪ ﻋﺪد ﻳﺎ ﻧﺎم ﻣﺘﻐﻴﺮ ﻣﺤﻠﻲ آﻪ ذآﺮ ﻣﻲ آﻨﻴﺪ وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ‪ ،‬اي ﺗـﺎﺑﻊ ﻳـﻚ‬ ‫ﻣﻘﺪار ﺧﺎﻟﻲ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪.‬‬ ‫ﺑﺮاي ﺑﻪ دﺳﺖ ﺁوردن ﻣﻘﺎدﻳﺮ ﻣﺘﻐﻴﺮهﺎي ﻣﺤﻠﻲ ﻣﻮﺟﻮد در ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﺧﻮد‪ ،‬ﺑـﻪ ﺗﺮﺗﻴـﺐ از ﻋـﺪد‬ ‫‪ ١‬ﺷﺮوع آﺮدﻩ و اﻳﻦ اﻋﺪاد را در ﺁرﮔﻮﻣـﺎن ‪ expression‬ﻗـﺮار دهﻴـﺪ ﺗـﺎ زﻣـﺎﻧﻲ آـﻪ اﻳـﻦ ﺗـﺎﺑﻊ‪ ،‬ﻳـﻚ‬ ‫ﻣﻘﺪار ﺧﺎﻟﻲ را ﺑﺮﮔﺸﺖ دهﺪ‪.‬‬ ‫اﮔﺮ ‪ X‬ﻣﺜﺒﺖ و ‪ Y‬ﻣﻨﻔﻲ ﺑﺎﺷﺪ‪ ،‬ﻣﺘﻐﻴﺮ ‪ ،Test‬ﻣﻘﺪار ‪ ٢‬را ﺧﻮاهـﺪ داﺷـﺖ و ﺑﻘﻴـﻪ ﺷـﺮوط ﺑـﻪ هﻤـﻴﻦ‬ ‫ﺗﺮﺗﻴﺐ‪.value1.‬‬ ‫ﻣﺘﻐﻴﺮهﺎي ﻣﺤﻠﻲ‪ ،‬ﻣﺘﻐﻴﺮهﺎي ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ هﺴﺘﻨﺪ آـﻪ ﺑـﺎ ﻓﺮﻣـﺎن ‪ SET‬در ﺁن ﻗـﺮار دادﻩ ﺷـﺪﻩ‬ ‫اﻧﺪ‪.expression2.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪:‬‬ ‫‪TMP=C:\WINDOWS \TEMP‬‬ ‫ﺑﺮاي ﺑﻪ دﺳﺖ ﺁوردن ﺗﻨﻬﺎ‪ ،‬ﻣﻘـﺪار ﻣﺘﻐﻴـﺮ ﻣﺤﻠـﻲ ‪ ،TMP‬ﺑﺎﻳـﺪ ﻧـﺎم ﺁن را در ﺁرﮔﻮﻣـﺎن ‪expression‬‬ ‫ذآﺮ آﻨﻴﺪ هﻤﺎﻧﻨﺪ زﻳﺮ‪:‬‬ ‫))” ‪Console.NET‬‬ ‫‪٦٣‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ . X<0 and Y<0. 3.‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻟﻴﺴﺘﻲ از ﻋﺒﺎرات ورودي را ﺑﺎ ﻳﻜﺪﻳﮕﺮ ﻣﻘﺎﻳﺴﻪ آﺮدﻩ و ﻣﻘﺪار اوﻟـﻴﻦ ﻋﺒـﺎرﺗﻲ آـﻪ ﺻـﺤﻴﺢ‬ ‫ﺑﺎﺷﺪ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪ .WriteLine(Environ(2‬‬ ‫ﺑﻪ آﻤﻚ دﺳﺘﻮر ﻓﻮق‪ ،‬هﻢ‪ ،‬ﻧﺎم ﻣﺘﻐﻴﺮ ﻣﺤﻠﻲ و هﻢ ﻣﻘﺪار ﺁن در ﺧﺮوﺟﻲ ﻧﻤﺎﻳﺶ دادﻩ ﻣﻲ ﺷﻮد‪.‬‬ ‫دﺳﺘﻮ زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬ ‫))‪Console.‬‬ ‫ﺑﺮاي دﺳﺘﺮﺳﻲ ﺑﻪ ﻣﺤﺘﻮﻳﺎت ﻳـﻚ ﻣﺘﻐﻴـﺮ ﻣﺤﻠـﻲ در ﺳﻴـﺴﺘﻢ‪ ،‬از ﻳـﻚ ﻋـﺪد ﻳـﺎ ﻧـﺎم ﺁن در ﺁرﮔﻮﻣـﺎن‬ ‫‪ expression‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ‪.‬در ﺻﻮرﺗﻲ آـﻪ هﻴﭽﻜـﺪام از ﻋﺒـﺎرات ﺻـﺤﻴﺢ ﻧﺒﺎﺷـﻨﺪ‪ ،‬اﻳـﻦ ﺗـﺎﺑﻊ ﻳـﻚ ﻣﻘـﺪار‬ ‫‪ Null‬را ﺑﺮﮔﺸﺖ ﺧﻮاهﺪ داد‪. 4‬‬ ‫در دﺳﺘﻮر ﻓﻮق ﭼﻨﺎﻧﭽﻪ ‪ X‬و ‪ ،Y‬ﻣﺜﺒﺖ ﺑﺎﺷﻨﺪ ﻣﻘﺪار ‪ ١‬در ﻣﺘﻐﻴﺮ ‪ Test‬ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ‪.‬‬ ‫)‪Environ(expression‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺟﻬﺖ ﺑﺮﮔﺸﺖ ﻣﺘﻐﻴﺮهﺎي ﻣﺤﻠﻲ ﺑﻪ آﺎر ﻣﻲ رود‪.‫)…‪Switch(expression1.‬‬ ‫ﺗﻮﺟﻪ‪ :‬اﮔﺮ ‪ X‬و ‪ ،Y‬ﺻـﻔﺮ ﺑﺎﺷـﻨﺪ‪ ،‬هﻴﭽﻜـﺪام از ﻋﺒـﺎرات ﺻـﺤﻴﺢ ﻧﺨﻮاهﻨـﺪ ﺑـﻮد و ﻣﻘـﺪار ‪Null ،Test‬‬ ‫ﺧﻮاهﺪ ﺷﺪ‪. X<0 and Y>0. X<0 and Y<0.WriteLine(Environ(“WinDir‬‬ ‫ﺑﺎ اﺳﺘﻔﺎدﻩ از دﺳﺘﻮر ﻓﻮق ﻧﻴـﺎزي ﺑـﻪ اﺳـﺘﻔﺎدﻩ از ﺗـﺎﺑﻊ ‪ API‬ﺑـﺮاي ﺑـﻪ دﺳـﺖ ﺁوردن ﻣـﺴﻴﺮ ﻧـﺼﺐ‬ ‫وﻳﻨﺪوز ﻧﺪارﻳﺪ‪.‬‬ ‫ﻣﺜﺎل زﻳﺮ‪ ،‬ﻣﻘﺎدﻳﺮ ﻣﻮﺟـﻮد در ﻣﺘﻐﻴﺮهـﺎي ‪ X‬و ‪ Y‬را ﭼـﻚ آـﺮدﻩ و ﻣﺘﻨﺎﺳـﺐ ﺑـﺎ ﻧـﻮع ﻋﺒـﺎرات ﺷـﺮﻃﻲ‬ ‫ﺗﻌﺮﻳﻒ ﺷﺪﻩ‪ ،‬ﻣﻘﺪاري را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‪:‬‬ ‫)‪Test =Switch(X>0 and Y>0.WriteLine(Environ(“TMP‬‬ ‫دﺳﺘﻮر ﻓﻮق‪ ،‬ﻋﺒﺎرت زﻳﺮ را ﻧﻤﺎﻳﺶ ﺧﻮاهﺪ داد‪:‬‬ ‫‪C:\WINDOWS \TEMP‬‬ ‫ﻣﺜﻼ دﺳﺘﻮر زﻳﺮ‪ ،‬ﻣﺴﻴﺮ ﭘﻮﺷﻪ وﻳﻨﺪوز ﺷﻤﺎ را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ‪:‬‬ ‫)”‪Console. 2.

Set.‫‪Beep‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺟﻬﺖ اﻳﺠﺎد ﻳﻚ ﺻﺪاي ﺑﻴﭗ آﻮﺗﺎﻩ ﺑﻪ آﺎر ﻣﻲ رود‪.NET‬‬ ‫ﺗﻮﺟﻪ‪ :‬اوﻟﻴﻦ ﺁرﮔﻮﻣﺎن آﻪ ﺑﺎﻳﺪ ﻧﺎم ﺷﻲ ﻣﻮرد ﻧﻈـﺮ در ﺁن ذآـﺮ ﺷـﻮد‪ ،‬ﻳـﻚ ﻣﻘـﺪار رﺷـﺘﻪ اي ﻧﻴـﺴﺖ‬ ‫ﺑﻠﻜﻪ ﻧﺎم اﺻﻠﻲ ﺷﻲ را ﺑﺪون هﻴﭻ آﺎراآﺘﺮ اﺿﺎﻓﻲ ﺑﺎﻳﺪ ذآﺮ آﺮد‪.‬‬ ‫اﮔﺮ از ﻣﻘﺪار ‪ Set‬اﺳﺘﻔﺎدﻩ آﻨﻴﻢ‪ ،‬ﺑﺎﻳﺪ ﻣﻘﺪاري را آﻪ ﻣﻲ ﺧﻮاهﻴﻢ ﺑﻪ ﻳﻜﻲ از ﺧﺎﺻﻴﺖ هـﺎي ﺷـﻲ‬ ‫ﻧﺴﺒﺖ دهﻴﻢ در اﻳﻦ ﺁرﮔﻮﻣﺎن ذآﺮ آﻨﻴﻢ‪.Get‬‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic. “Text”. “Text”.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،procedurename‬ﻧﺎم ﻳﻚ ﺧﻮاص ﻳﺎ ﻣﺘﺪ ﺷﻲ اﺳﺖ‪.Text = “Welcome To VB. “Welcome to VB.NET‬‬ ‫در ﺻﻮرﺗﻲ آﻪ ﻣﻲ ﺧﻮاهﻴﺪ ﻧﺎم ﺷـﻲ را در ﻳـﻚ ﻣﺘﻐﻴـﺮ ﻗـﺮار دهﻴـﺪ ﺑﺎﻳـﺪ اﺑﺘـﺪا ﺁن را از ﻧـﻮع ‪Object‬‬ ‫ﺗﻌﺮﻳﻒ آﻨﻴﺪ‪ .‬ﭘﺲ دﺳﺘﻮر ﻓﻮق را ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺻﻼح ﻣﻲ آﻨﻴﻢ‪:‬‬ ‫‪Dim MyObject As Object‬‬ ‫‪MyObject =TextBox1‬‬ ‫”‪CallByName MyObject.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،object‬ﻧﺎم ﺷﻲ ﻣﻮرد ﻧﻈﺮ اﺳﺖ‪.arguments‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺟﻬﺖ اﺟﺮاي ﻳﻜﻲ از ﻣﺘﺪهﺎي ﻳﻚ ﺷﻲ ﻳﺎ ﺗﻌﻴﻴﻦ ﻣﻘﺪار ﺧﻮاص ﺷﻲ ﻳـﺎ ﺑﺮﮔﺮداﻧـﺪن ﻣﻘـﺪار‬ ‫ﻳﻜﻲ از ﺧﻮاص ﺷﻲ ﺑﻪ آﺎر ﻣﻲ رود‪.‬‬ ‫)])(‪CallByName(object. “Welcome to VB.‬‬ ‫اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ ﻧﻴﺎزي ﺑﻪ ﻧﺼﺐ ﺑﻮدن ﻳﺎ داﺷﺘﻦ آﺎرت ﺻﺪا ﻧﺪارد‪.Set.‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،calltype‬ﻧﻮع ﻋﻤﻠـﻲ آـﻪ ﻣـﻲ ﺧـﻮاهﻴﻢ اﻧﺠـﺎم ﺷـﻮد را ﻣـﺸﺨﺺ ﻣـﻲ آﻨـﺪ و ﻳﻜـﻲ از‬ ‫ﻣﻘﺎدﻳﺮ زﻳﺮ را ﻣﻲ ﭘﺬﻳﺮد‪:‬‬ ‫ﻣﻘﺎدﻳﺮ‬ ‫ﻣﻘﺪار‬ ‫‪Get‬‬ ‫‪Set‬‬ ‫ﭘﺎراﻣﺘﺮ ‪ calltype‬در ﺗﺎﺑﻊ )(‪CallByName‬‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻣﻘﺪار ﻳﻚ ﺧﺎﺻﻴﺖ ﺷﻲ را ﻣﻲ ﺧﻮاﻧﺪ‬ ‫ﻣﻘﺪار ﻳﻚ ﺧﺎﺻﻴﺖ ﺷﻲ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ‬ ‫ﻳﻚ ﻣﺘﺪ از ﺷﻲ را ﻓﺮاﺧﻮاﻧﻲ و اﺟﺮا ﻣﻲ آﻨﺪ‬ ‫‪Method‬‬ ‫ﺁﺧﺮﻳﻦ ﺁرﮔﻮﻣﺎن اﻳﻦ ﺗﺎﺑﻊ آﻪ ‪ arguments‬ﻧﺎم دارد‪ ،‬ﻳﻚ ﺁراﻳﻪ از ﻣﻘﺎدﻳﺮ اﺳﺖ‪. CallType. CallType. CallType.calltype [.‬‬ ‫ﻃﻮل زﻣﺎن ﭘﺨﺶ اﻳﻦ ﺻﺪاي ﺑﻴﭗ‪ ،‬ﻗﺎﺑﻞ ﺗﻨﻈﻴﻢ ﻧﻴﺴﺖ‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺑﻪ ﻃﻮر ﻣﻌﻤﻮل ﺑﺮاي ﺁﻧﻜﻪ ﺑﻪ ﺧﺎﺻﻴﺖ ‪ Text‬از ﺷﻲ ‪ ،TextBox‬ﻣﻘﺪاري را ﻧﺴﺒﺖ‬ ‫دهﻴﻢ‪ ،‬ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ‪:‬‬ ‫"‪TextBox1. “Text”. “Text ”.NET‬‬ ‫ﺑﺮاي ﺑﻪ دﺳﺖ ﺁوردن ﻣﻘﺪار ﺧﺎﺻﻴﺖ ‪ Text‬از ﺷﻲ ‪ TextBox‬ﻧﻴﺰ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ آﻨﻴﺪ‪:‬‬ ‫)‪MyText = CallByName(TextBox1.NET‬‬ ‫‪٦٤‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ‪ :‬ﺑﻬﺮوز راد‬ .‬‬ ‫اﮔﺮ از ﻣﻘﺪار ‪ Method‬اﺳﺘﻔﺎدﻩ ﻣﻲ آﻨﻴﻢ‪ ،‬ﻣﻤﻜﻦ اﺳﺖ ﻣﺘﺪ ﺗﺎﺑﻊ ﻣﺎ ﺑﺮاي اﻧﺠﺎم آﺎر ﺧـﻮد ﻧﻴـﺎز ﺑـﻪ‬ ‫ﭘﺎراﻣﺘﺮهﺎ ﻳﺎ ﻣﻘﺎدﻳﺮي داﺷﺘﻪ ﺑﺎﺷﺪ‪ ،‬ﭘﺲ ﺁﻧﻬﺎ را ﺑﻪ ﺗﺮﺗﻴﺐ در اﻳﻦ ﺁرﮔﻮﻣﺎن ﻳﻌﻨﻲ ‪ arguments‬ذآﺮ‬ ‫ﻣﻲ آﻨﻴﻢ‪.‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪ ،‬دﺳﺘﻮر زﻳﺮ اﺷﺘﺒﺎﻩ اﺳﺖ و ﻳﻚ ﺧﻄﺎي زﻣﺎن اﺟﺮا اﺗﻔﺎق ﺧﻮاهﺪ اﻓﺘﺎد‪:‬‬ ‫”‪ObjectName =“TextBox1‬‬ ‫”‪CallByName ObjectName.Set. “Welcome to VB.NET‬‬ ‫ﺣﺎﻻ هﻤﻴﻦ آﺎر را ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ CallByName‬اﻧﺠﺎم ﻣﻲ دهﻴﻢ‪:‬‬ ‫)” ‪CallByName(TextBox1.procedurename. CallType.

NET ٢٠٠١ ‫ ﺑﻬﺮوز راد‬:‫ﺑﻪ وﺳﻴﻠﻪ‬ ٦٥ Visual Basic.NET ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ‬ .‫ﺗﺎرﻳﺨﭽﻪ وﻳﮋوال ﺑﻴﺴﻴﻚ‬ Visual Basic 1.0 ١٩٩١ ‫ ﻣﻲ‬٢٠ Visual Basic 2.0 ١٩٩٨ ‫ ژوﺋﻦ‬١٦ Visual Basic .0 ١٩٩٦ ‫اآﺘﺒﺮ‬ Visual Basci 5.0 ١٩٩٣ ‫ژوﺋﻦ‬ Visual Basci 4.0 ١٩٩٧ ‫ﺁورﻳﻞ‬ Visual Basic 6.0 ١٩٩٢ ‫ﻣﺎرس‬ Visual Basci 3.