Uploaded byguestf2e12d
325 views

vb.net

Embed presentation

Downloaded 34 times
‫ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫آﺘﺎب اﻟﻜﺘﺮوﻧﻴﻜﻲ ﺁﻣﻮزﺷﻲ - آﺎرﺑﺮدي ﻓﺎرﺳﻲ ﺗﻮاﺑﻊ ‪VB.NET‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫آﺘﺎب…‬ ‫درﺑﺎرﻩ‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬ ‫ﻧﺎم آﺘﺎب‬ ‫ﺑﻬﺮوز راد‬ ‫ﻧﻮﻳﺴﻨﺪﻩ‬ ‫داﻧﺸﺠﻮي آﺎﻣﭙﻴﻮﺗﺮ‬ ‫ﺗﺤﺼﻴﻼت‬ ‫زﻣﺴﺘﺎن ٢٨٣١‬ ‫ﺗﺎرﻳﺦ ﺗﺎﻟﻴﻒ‬ ‫٥٦ ﺻﻔﺤﻪ‬ ‫ﺗﻌﺪاد‬ ‫ﺻﻔﺤﺎت‬ ‫ﺗﻮﺟﻪ: اﺳﺘﻔﺎدﻩ از ﻣﻄﺎﻟﺐ اﻳﻦ آﺘﺎب ﺑﺎ ذآﺮ ﻧﺎم ﻣﺆﻟﻒ ﺑﻼﻣﺎﻧﻊ اﺳﺖ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﻣﻘﺪﻣﻪ:‬ ‫ﺳﭙﺲ ﺧﺪاي را آﻪ در آﻨﺎر ﻧﻌﻤﺎت ﺑﻴﻜﺮان ﺧﻮد، ﺗﻮﻓﻴﻖ اراﺋﻪ اﻳﻦ آﺘﺎب ﺁﻣﻮزﺷﻲ را ﺑـﻪ دوﺳـﺘﺪاران‬ ‫زﺑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ‪ Visual Basic.NET‬ﻋﻨﺎﻳﺖ ﻓﺮﻣﻮد.‬ ‫در ﺑﺮاﺑﺮ اﻧﺒﻮﻩ آﺘﺎب هﺎي اﻟﻜﺘﺮوﻧﻴﻜﻲ ﺁﻣﻮزﺷﻲ اﻧﮕﻠﻴﺴﻲ زﺑﺎن در ﻣﻮرد زﺑﺎن هﺎي ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳـﺴﻲ،‬ ‫آﻤﺒﻮد آﺘﺎب هﺎي ﻓﺎرﺳﻲ در آﺸﻮر ﻣﺎ ﺑﻪ ﺷﺪت اﺣﺴﺎس ﻣﻲ ﺷﻮد.‬ ‫از ﺁن ﻣﻬﻢ ﺗﺮ، آﺘﺎﺑﻲ آﻪ ﺑﺮ روي ﻳﻚ ﻗﺴﻤﺖ از ﻳﻚ زﺑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺗﻤﺮآﺰ داﺷﺘﻪ و ﺑـﻪ ﻧﺤـﻮي‬ ‫ﺷﺎﻳﺴﺘﻪ و ﺑﻪ ﮔﻮﻧﻪ اي ﺳﺎدﻩ ﺑﻪ ﺗﻮﺿﻴﺢ ﻣﺒﺤﺚ ﺑﭙﺮدازد، ﺑﻪ ﻧﺪرت دﻳﺪﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫از اﻳﻦ رو ﺑﺮ ﺁن ﺷﺪم ﺗﺎ ﺑﺎ اراﺋﻪ اﻳﻦ آﺘﺎب اﻟﻜﺘﺮوﻧﻴﻜﻲ ﺁﻣﻮزﺷﻲ - آﺎرﺑﺮدي، ﻣﻬﻤﺘﺮﻳﻦ ﺗﻮاﺑﻊ ﻣﻮﺟـﻮد‬ ‫در زﺑﺎن ‪ VB.NET‬را آﻪ اآﺜﺮا ﺑﺎ زﺑﺎن 0.6.‪ VB‬ﻣﺸﺘﺮك هﺴﺘﻨﺪ، ﺑﻪ ﺻﻮرت دﺳـﺘﻪ ﺑﻨـﺪي ﺷـﺪﻩ و ﺑـﻪ‬ ‫ﻃﻮر آﺎﻣﻞ و ﺑﺎ ﺟﺰﺋﻴﺎت آﺎﻣﻞ ﺗﺮ، ﺑﺎ زﺑﺎﻧﻲ ﺳﺎدﻩ و اراﺋﻪ ﻣﺜﺎل هـﺎي ﻣﺘﻌـﺪد ﺟﻬـﺖ ﻳـﺎدﮔﻴﺮي و ﻓﻬـﻢ‬ ‫ﺑﻬﺘﺮ، ﺑﻪ دوﺳﺘﺪاران اﻳﻦ زﺑﺎن ﻗﺪرﺗﻤﻨﺪ اراﺋﻪ آﻨﻢ.‬ ‫از ﺁﻧﺠﺎ آﻪ هﻴﭻ ﻧﻮﺷﺘﻪ اي ﺑﻪ ﻃﻮر آﺎﻣﻞ ﺧﺎﻟﻲ از ﻧﻘﺺ و اﻳﺮاد ﻧﻴـﺴﺖ، ﻟـﺬا از ﺗﻤـﺎﻣﻲ ﺧﻮاﻧﻨـﺪﮔﺎن‬ ‫ﮔﺮاﻣﻲ ﺧﻮاهﺸﻤﻨﺪم اﺷﺘﺒﺎهﺎت آﺘﺎب را ﺑﻪ ﻃـﻮر ﻣـﺴﺘﻘﻴﻢ ﺑـﺎ ﺑﻨـﺪﻩ از ﻃﺮﻳـﻖ اﻳﻤﻴـﻞ زﻳـﺮ در ﻣﻴـﺎن‬ ‫ﺑﮕﺬارﻧﺪ.‬ ‫اﻣﻴﺪ اﺳﺖ آﻪ ﺑﺎ اﻳﻦ آﺎر آﻮﭼﻚ، ﮔﺎﻣﻲ در ﺟﻬﺖ اﻓﺰاﻳﺶ داﻧﺎﻳﻲ و ﺳﻄﺢ ﻋﻠﻤﻲ دوﺳـﺘﺪاران اﻳـﻦ‬ ‫زﺑﺎن ﺑﺮداﺷﺘﻪ ﺷﻮد.‬ ‫ﺑﻪ اﻣﻴﺪ ﻣﻮﻓﻘﻴﺖ روز اﻓﺰون.‬ ‫ﺑﻬﺮوز راد‬ ‫زﻣﺴﺘﺎن ٢٨٣١‬ ‫‪behrouz.rad@gmail.com‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﻧﻜﺎت ﻣﻬﻢ:‬ ‫١( اآﺜ ـﺮ ﺗﻮاﺑــﻊ ‪ ،VB.NET‬ﺷــﺒﻴﻪ ﺑ ـﻪ ﺗﻮاﺑــﻊ ﻣﻮﺟــﻮد در 0.6.‪ VB‬ه ـﺴﺘﻨﺪ و ﺗﻨﻬــﺎ در ﺑﺮﺧــﻲ ﻣــﻮارد،‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ﺗﻐﻴﻴﺮاﺗﻲ در ﻧﺤﻮﻩ ي ﻓﺮاﺧﻮاﻧﻲ و اﺣﻴﺎﻧﺎ ﺳﻴﻨﺘﻜﺲ ﺗﺎﺑﻊ وﺟﻮد دارد.‬ ‫ﺑـﻪ ﻋﻨـﻮان ﻣﺜـﺎل ﺗـﺎﺑﻊ )(‪ Len‬در 0.6.‪ VB‬ﻃـﻮل ﻳـﻚ رﺷـﺘﻪ را ﺑﺮﮔـﺸﺖ ﻣـﻲ دهـﺪ اﻣـﺎ در ‪VB.NET‬‬ ‫ﺷﻤﺎ ﻗﺎدر ﺑﻪ اﻧﺠﺎم اﻳﻦ آﺎر را ﺑﺎ اﺳﺘﻔﺎدﻩ از ﻣﺘﺪ ‪ Length‬ﻣﺘﻐﻴﺮ رﺷﺘﻪ اي هﺴﺘﻴﺪ.‬ ‫ﻓﺮﺿﺎ اﮔﺮ ﻣﺘﻐﻴﺮ ‪ StrVar‬ﺑﻪ ﻋﻨﻮان ﻳﻚ ﻣﺘﻐﻴﺮ رﺷﺘﻪ اي ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﺑﺎﺷﺪ، ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴـﺪ ﻃـﻮل‬ ‫ﺁن را ﺑﺎ اﺳﺘﻔﺎدﻩ از ﻣﺘﺪ ‪ Length‬اﻳﻦ ﻣﺘﻐﻴﺮ ﺑﻪ دﺳﺖ ﺁورﻳﺪ:‬ ‫” ‪Dim strVar As String =“a short string‬‬ ‫)”‪Console.WriteLine(“The string contains“ & strVar.Length & “characters‬‬ ‫ﻳﺎ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻃﻮل اﻳﻦ ﻣﺘﻐﻴﺮ رﺷﺘﻪ اي را ﺑﺎ ﻗﺮار دادن ﺁن در ﺁرﮔﻮﻣﺎن ﺗﺎﺑﻊ )(‪ Len‬ﺑـﻪ دﺳـﺖ‬ ‫ﺁورﻳﺪ:‬ ‫”‪Dim strVar As String =“a short string‬‬ ‫)”‪Console.WriteLine(“The string contains “ & Len(strVar) & “characters‬‬ ‫٢( در ‪ VB.NET‬ﺗﻮاﺑﻌﻲ هﺴﺘﻨﺪ آﻪ آﺎر ﺗﻘﺮﻳﺒﺎ ﻳﻜﺴﺎﻧﻲ اﻧﺠﺎم ﻣﻲ دهﻨﺪ و اﻳﻦ ﻧﻜﺘﻪ ﺑـﺴﻴﺎر ﻣﻬـﻢ‬ ‫اﺳﺖ آﻪ ﺷﻤﺎ ﺑﻨﺎ ﺑﻪ ﻧﻴﺎز ﺧﻮد ﺗﺸﺨﻴﺺ دهﻴﺪ آﻪ ﺑﺎﻳﺪ از آﺪاﻣﻴﻚ از اﻳﻦ ﺗﻮاﺑﻊ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫٣( اﮔـﺮ ﺷـﻤﺎ ﻳﻜـﻲ از ﺁرﮔﻮﻣـﺎن هـﺎي اﺧﺘﻴـﺎري را ﺣـﺬف آﻨﻴـﺪ، ﺑﺎﻳـﺪ ﺑـﻪ ﺟـﺎي ﺁن از آـﺎراآﺘﺮ آﺎﻣـﺎ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫٤( ﺁرﮔﻮﻣﺎن هﺎي اﺧﺘﻴﺎري داﺧﻞ آﺮوﺷﻪ ﻗﺮار دارﻧﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺷﻜﻞ آﻠﻲ ﺗـﺎﺑﻊ )(‪ Mid‬آـﻪ ﺗﻌـﺪادي از آﺎراآﺘﺮهـﺎي ﻳـﻚ رﺷـﺘﻪ را از ﺁن اﺳـﺘﺨﺮاج‬ ‫ﻣﻲ آﻨﺪ ﺑﻪ ﺻﻮرت زﻳﺮ اﺳﺖ:‬ ‫] ‪newString =Mid(string [,start ][,length‬‬ ‫ﻣﺤــﻞ ﺷــﺮوع آﺎراآﺘﺮهــﺎﻳﻲ آــﻪ ﺑﺎﻳــﺪ اﺳــﺘﺨﺮاج ﺷــﻮﻧﺪ ﺑــﻪ وﺳــﻴﻠﻪ ﺁرﮔﻮﻣــﺎن ‪ Start‬و ﺗﻌــﺪاد‬ ‫آﺎراآﺘﺮهﺎﻳﻲ آﻪ ﺑﺎﻳﺪ اﺳﺘﺨﺮاج ﺷﻮﻧﺪ را ﺁرﮔﻮﻣﺎن ‪ length‬ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ.‬ ‫هﻤﺎﻧﮕﻮﻧﻪ آﻪ ﻣﻼﺣﻈﻪ ﻣﻲ ﺷﻮد ﺁرﮔﻮﻣﺎن ‪ start‬ﻳـﻚ ﺁرﮔﻮﻣـﺎن اﺧﺘﻴـﺎري ﺑـﻮدﻩ و ﭼﻨﺎﻧﭽـﻪ اﺳـﺘﻔﺎدﻩ‬ ‫ﻧﺸﻮد ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﻣﺤﻞ ﺷﺮوع اﺳﺘﺨﺮاج آﺎراآﺘﺮهﺎ از اﺑﺘﺪا ﻳﻌﻨـﻲ اوﻟـﻴﻦ آـﺎراآﺘﺮ رﺷـﺘﻪ در‬ ‫ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫اﮔﺮ ﺁرﮔﻮﻣﺎن ‪ length‬اﺳﺘﻔﺎدﻩ ﻧﺸﻮد، از ﻣﻜﺎن ﻣﺸﺨﺺ ﺷﺪﻩ ﺗﺎ ﺑﻪ اﻧﺘﻬﺎي رﺷـﺘﻪ اﺳـﺘﺨﺮاج ﻣـﻲ‬ ‫ﺷﻮﻧﺪ.‬ ‫ﺗﻨﻬﺎ ﺁرﮔﻮﻣﺎن اﺟﺒﺎري در اﻳﻦ ﺗﺎﺑﻊ، اوﻟﻴﻦ ﺁرﮔﻮﻣﺎن ﻳﻌﻨﻲ ‪ String‬ﻣﻲ ﺑﺎﺷﺪ آﻪ رﺷـﺘﻪ اي را ﺗﻌﻴـﻴﻦ‬ ‫ﻣﻲ آﻨﺪ آﻪ آﺎراآﺘﺮهﺎ ﺑﺎﻳﺪ از ﺁن اﺳﺘﺨﺮاج ﺷﻮﻧﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫در زﻳﺮ، ﺗﻤﺎﻣﻲ ﺗﻮاﺑﻊ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻩ در اﻳﻦ آﺘﺎب ﺑﻪ ﺻـﻮرت دﺳـﺘﻪ ﺑﻨـﺪي ﺷـﺪﻩ ﻟﻴـﺴﺖ ﺷـﺪﻩ‬ :‫اﺳﺖ‬ .‫ﺗﻮﺟﻪ: ﺗﻮاﺑﻌﻲ آﻪ در اﻧﺘﻬﺎي ﺁﻧﻬﺎ ﭘﺮاﻧﺘﺰ وﺟﻮد ﻧﺪارد، ﺗﻮاﺑﻊ ﺑﺪون ﺁرﮔﻮﻣﺎن هﺴﺘﻨﺪ‬ :(Input/output) ‫ﺗﻮاﺑﻊ ورودي/ﺧﺮوﺟﻲ‬ InputBox(),MsgBox() :(File and Folder Manipulation) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ ﻓﺎﻳﻞ هﺎ و ﭘﻮﺷﻪ هﺎ ﺳﺮ و آﺎر دارﻧﺪ‬ ChDir(),ChDrive(),CurDir(),Dir(),FileCopy(),FileDateTime(),FileLen,GetAttr(),Kill,MkDir(),Rename(),RmDir() SetAttr() :(Data Type Identification) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺮاي ﺷﻨﺎﺳﺎﻳﻲ ﻧﻮع دادﻩ هﺎ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‬ IsArray(),IsDate(),IsDBNull(),IsNothing(),IsNumeric(),IsReference,TypeName(),VarType() :(Variable Type Conversion) ‫ﺗﻮاﺑﻊ ﺗﺒﺪﻳﻞ ﻧﻮع ﻣﺘﻐﻴﺮ‬ CBool(),CByte(),CChar(),CDate(),CDbl(),CDec(),CInt(),CLng(),CObj(),CShort(),CSng(),CStr(),CType() :(String Manipulation) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ رﺷﺘﻪ هﺎ ﺳﺮ و آﺎر دارﻧﺪ‬ Asc(),AscW(),Chr(),ChrW(),Filter(),InStr(),InStrRev(),Join(),LCase(),Left(),Len(),LTrim(),Mid(),Mid,Replace(), Right(),RTrim(),Space(),Split(),StrComp(),StrConv(),StrDup(),StrReverse(),Trim(),UCase() :(Data Formatting) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ دادﻩ هﺎ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‬ Format(),FormatCurrency(),FormatDateTime(),FormatNumber(),FormatPercent(),LSet(),RSet(),Str(),Val() :(Math) ‫ﺗﻮاﺑﻊ رﻳﺎﺿﻲ‬ Abs(),Atan(),Cos(),Exp(),Fix(),Hex(),Int(),Log(),Oct(),Pow(),Round(),Sin(),Sqrt(),Tan() :(Date and Time) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ ﺗﺎرﻳﺦ و زﻣﺎن ﺳﺮ و آﺎر دارﻧﺪ‬ DateAdd(),DateDiff(),DatePart(),DateSerial(),DateValue(),Day(), Hour(),Minute(),Month(),MonthName(),Now(),Second(), TimeSerial(),TimeValue(),Weekday(),WeekdayName(),Year() ‫( ﺑ ـﺮ روي ﻓﺎﻳ ـﻞ ه ـﺎ ﻣ ـﻮرد‬I/O) ‫ﺗ ـﻮاﺑﻌﻲ آ ـﻪ ﺟﻬ ـﺖ اﻧﺠ ـﺎم ﻋﻤﻠﻴ ـﺎت ورودي/ﺧﺮوﺟ ـﻲ‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ :(File I/O) ‫اﺳﺘﻔﺎدﻩ ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ‬ EOF(),FileAttr(),FileClose(),FileOpen(),FileGet(),FilePut(),FreeFile(), Input(),LineInput(),Loc(),Lock(),LOF(),Print(),PrintLine(),Reset(), Seek(),Unlock(),Width(),Write(),WriteLine() :(Random Numbers) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺮاي درﺳﺖ آﺮدن اﻋﺪاد ﺗﺼﺎدﻓﻲ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‬ Rnd(),Randomize :(Graphics) ‫ﺗﻮاﺑﻊ ﮔﺮاﻓﻴﻜﻲ‬ QBColor(),RGB() :(Registry) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ رﺟﻴﺴﺘﺮي ﺳﺮ و آﺎر دارﻧﺪ‬ DeleteSetting(),GetAllSettings(),GetSetting(),SaveSetting() :(Application Collaboration) ‫ﺗﻮاﺑﻊ آﺎرﺑﺮدي‬ AppActivate(),Shell() :(Miscellaneous) ‫ﺗﻮاﺑﻊ ﻣﺘﻔﺮﻗﻪ‬ Beep,CallByName(),Choose(),Environ(),IIf(),Option,Switch() ‫در اداﻣﻪ، ﺗﻤﺎﻣﻲ ﺗﻮاﺑﻊ ذآﺮ ﺷﺪﻩ ﺑﻪ ﺗﺮﺗﻴﺐ دﺳﺘﻪ ﺑﻨـﺪي و ﺗـﻚ ﺗـﻚ، هﻤـﺮاﻩ ﺑـﺎ ﻣﺜـﺎل ﺗﻮﺿـﻴﺢ دادﻩ‬ .‫ﺧﻮاهﻨﺪ ﺷﺪ‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ٥ Visual Basic.NET ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ‬
‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﺗﻮاﺑﻊ ﻣﻮﺟﻮد در هﺮ دﺳﺘﻪ ﺑﻪ ﺗﺮﺗﻴﺐ ﺣﺮوف اﻟﻔﺒﺎ ﺗﻮﺿﻴﺢ دادﻩ ﻧـﺸﺪﻩ ﺑﻠﻜـﻪ‬ ‫از ﺁﺳﺎﻧﺘﺮﻳﻦ ﺷﺮوع ﺷﺪﻩ اﺳﺖ. ﺑﻨﺎﺑﺮاﻳﻦ ﻓﺮﺻﺖ اﻳـﻦ را ﺧـﻮاهﻢ داﺷـﺖ ﺗـﺎ در ﻣﺜـﺎل هـﺎﻳﻲ آـﻪ در‬ ‫ﺗﻮاﺑﻊ دﻳﮕﺮ ﺧﻮاهﻢ زد از ﺗﻮاﺑﻊ دﻳﮕﺮ ﻧﻴﺰ ﺑﺎ هﻤﺪﻳﮕﺮ اﺳﺘﻔﺎدﻩ آﻨﻢ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٦‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)‪:(Input/output‬‬ ‫ﺗﻮاﺑﻊ ورودي/ﺧﺮوﺟﻲ‬ ‫وﻳﮋوال ﺑﻴﺴﻴﻚ دو ﺗﺎﺑﻊ اﺳﺎﺳﻲ را ﺟﻬﺖ ﻧﻤﺎﻳﺶ ﻳﺎ درﺧﻮاﺳﺖ اﻃﻼﻋﺎت ﺑﻪ ﻳﺎ از آﺎرﺑﺮ ﻓﺮاهﻢ آﺮدﻩ‬ ‫اﺳﺖ.‬ ‫اﻳﻦ دو ﺗﺎﺑﻊ ﻋﺒﺎرﺗﻨﺪ از: )(‪MsgBox() , InputBox‬‬ ‫ﺑﺮﻧﺎﻣﻪ هﺎي آﺎرﺑﺮدي ﺑﺎﻳﺪ ﺑﻪ ﻧﺤﻮي ﻣﻄﻠﻮب ﺑﺎ اﺳﺘﻔﺎدﻩ از ﻓﺮم هﺎي ﺟـﺬاب و آﺎرﺑﺮﭘـﺴﻨﺪ ﺑـﺎ آـﺎرﺑﺮ‬ ‫ﺧﻮد ارﺗﺒﺎط ﺑﺮﻗﺮار آﻨﻨﺪ.‬ ‫ﻳﻜﻲ از اﻳﻦ راﻩ هﺎي ارﺗﺒﺎط، اﺳﺘﻔﺎدﻩ از اﻳﻦ دو ﺗﺎﺑﻊ آﺎﻣﻼ آﺎرﺑﺮدي ﻣﻲ ﺑﺎﺷﺪ.‬ ‫)] ‪InputBox(prompt [,title ][,default ][,xpos ][,ypos‬‬ ‫ﺗﺎﺑﻊ ‪ InputBox‬ﺟﻬﺖ ﻧﻤﺎﻳﺶ ﻳﻚ ﺟﻌﺒﻪ ﮔﻔﺘﮕﻮ )‪ (DialogBox‬هﻤﺮاﻩ ﺑﺎ ﻳـﻚ ﭘﻴﻐـﺎم و ﻳـﻚ ﺟﻌﺒـﻪ‬ ‫ﻣﺘﻦ ﺑﻪ آﺎر ﻣﻲ رود.‬ ‫اﻳﻦ آـﺎدر ﻣﺤـﺎورﻩ ﺗـﺎ زﻣـﺎن ورود اﻃﻼﻋـﺎت از ﻃـﺮف آـﺎرﺑﺮ و آﻠﻴـﻚ دآﻤـﻪ ‪ OK‬ﻳـﺎ ‪ Cancel‬ﺑـﺮ روي‬ ‫ﺻﻔﺤﻪ ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن هﺎي اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺷﺮح زﻳﺮ ﻣﻲ ﺑﺎﺷﻨﺪ:‬ ‫‪ :prompt‬ﭘﻴﻐﺎﻣﻲ آﻪ در هﻨﮕﺎم ﻇﺎهﺮ ﺷﺪن آﺎدر ﻣﺤﺎورﻩ در ﺁن ﻇﺎهﺮ ﻣﻲ ﺷﻮد.‬ ‫ﻧﻜﺘـﻪ: اﮔـﺮ ﻧﻴـﺎز دارﻳـﺪ آـﻪ ﻣـﺘﻦ ‪ Prompt‬ﺷـﻤﺎ در ﭼﻨـﺪﻳﻦ ﺧـﻂ ﭼـﺎپ ﺷـﻮد ﺁن را ﺑـﺎ اﺳـﺘﻔﺎدﻩ از‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫آﺎراآﺘﺮهﺎي ﺧﻄﻲ ‪ VbCr‬ﻳﺎ ‪ VbLf‬ﺑﻪ آﺎر ﺑﺒﺮﻳﺪ.‬ ‫‪ :Title‬ﻋﻨﻮاﻧﻲ آﻪ در ﻧﻮار ﻋﻨﻮان آﺎدر ﻣﺤﺎورﻩ ﻇﺎهﺮ ﻣﻲ ﺷﻮد.‬ ‫ﺗﻮﺟﻪ: اﮔﺮ ﺷﻤﺎ از ذآﺮ اﻳﻦ ﺁرﮔﻮﻣـﺎن اﺧﺘﻴـﺎري ﺧـﻮدداري آﻨﻴـﺪ، ﻧـﺎم ﺑﺮﻧﺎﻣـﻪ ﺷـﻤﺎ در اﻳـﻦ ﻗـﺴﻤﺖ‬ ‫ﻧﻤﺎﻳﺶ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫‪ :Default‬ﻣﻘﺪار ورودي ﭘﻴﺶ ﻓﺮض آﺎدر ﻣﺤﺎورﻩ آﻪ در ﺟﻌﺒﻪ ﻣﺘﻦ ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ.‬ ‫ﺗﻮﺻﻴﻪ: اﮔﺮ ﻗﺼﺪ ﺗﺴﺮﻳﻊ در ﺗﺼﻤﻴﻢ ﮔﻴـﺮي آـﺎرﺑﺮ در وارد آـﺮدن ﻣﻘـﺪار ورودي را دارﻳـﺪ، ﻣﻘـﺪاري را‬ ‫ﺣﺘﻤﺎ در اﻳﻦ ﻗﺴﻤﺖ ذآﺮ آﻨﻴﺪ.‬ ‫‪ :Xpos,ypos‬ﻣﺨﺘﺼﺎت ﮔﻮﺷﻪ ي ﺳﻤﺖ ﭼﭗ و ﺑﺎﻻي اﻳﻦ آﺎدر ﻣﺤـﺎورﻩ از ﺻـﻔﺤﻪ ﻧﻤـﺎﻳﺶ را ﺑـﺎ‬ ‫اﻳﻦ ﻣﻘﺎدﻳﺮ ﺗﻌﻴﻴﻦ آﻨﻴﺪ.‬ ‫ﻧﻜﺘﻪ: اﻳﻦ واﺣﺪهﺎ ﺑﺮ ﺣﺴﺐ ‪ Twips‬ﻣﻲ ﺑﺎﺷﻨﺪ.‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ هﺮ ‪ Twips‬ﺑﺮاﺑﺮ ﺑﺎ ﻳﻚ – ﭼﻬﺎرهﺰارو ﭼﻬﺎرﺻﺪو ﭼﻬـﻞ هـﺰارم اﻳـﻨﭻ و ﻳـﻚ –‬ ‫ﭘﺎﻧﺼﺪو ﺷﺼﺖ و هﻔﺖ ﺻﺪم ﺳﺎﻧﺘﻲ ﻣﺘﺮ و ﻳﻚ ﺑﻴﺴﺘﻢ ﻧﻘﻄﻪ )‪ (Point‬اﺳﺖ.‬ ‫ﺳﺎدﻩ ﺗﺮﻳﻦ ﺷﻜﻞ آﺎرﺑﺮد ﺗﺎﺑﻊ )(‪ InputBox‬ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺖ:‬ ‫)” ‪SSN =InputBox(“Please enter your name and family‬‬ ‫ﻣﺘﻨﻲ را آﻪ آﺎرﺑﺮ در اﻳﻦ آﺎدر ﻣﺤﺎورﻩ وارد ﻣﻲ آﻨﺪ در ﻣﺘﻐﻴﺮ ‪ SSN‬ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ.‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ ﺗﺎﺑﻊ هﻤﻴﺸﻪ ﻣﻘﺪاري از ﻧـﻮع ‪ String‬ﻳـﺎ رﺷـﺘﻪ اي اﺳـﺖ، ﺣﺘـﻲ اﮔـﺮ آـﺎرﺑﺮ‬ ‫ﻣﻘﺪاري ﻋﺪدي را وارد آﻨﺪ.‬ ‫ﻧﻜﺘﻪ: هﻤﻴﺸﻪ ﻣﻘﺪاري را آﻪ ﺗﻮﺳﻂ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد ﭼﻚ آﻨﻴـﺪ. ﺑـﻪ ﻋﻨـﻮان ﻣﺜـﺎل‬ ‫ﻣﻤﻜﻦ اﺳﺖ آﺎرﺑﺮ ﻣﻘﺪاري را در آﺎدر ﻣﺤﺎورﻩ وارد ﻧﻜﻨﺪ.‬ ‫در ﺻﻮرﺗﻲ آﻪ ﻓﻜﺮ ﻣﻲ آﻨﻴﺪ آﺎرﺑﺮ ﻣﻘﺪاري ﻋﺪدي را در آﺎدر ﻣﺤﺎورﻩ وارد ﻣﻲ آﻨـﺪ ﺑـﺎ اﺳـﺘﻔﺎدﻩ از‬ ‫ﺗﺎﺑﻊ )(‪ IsNumeric‬ﻣﻘﺪار ورودي را ﭼﻚ آﻨﻴﺪ ﺗﺎ ﺣﺘﻤﺎ از اﻋﺪاد ﺗﺸﻜﻴﻞ ﺷﺪﻩ ﺑﺎﺷﺪ.‬ ‫در ﺻﻮرﺗﻲ آﻪ ﻓﻜـﺮ ﻣـﻲ آﻨﻴـﺪ آـﺎرﺑﺮ ﻣﻘـﺪاري از ﻧـﻮع ﺗـﺎرﻳﺦ را وارد ﻣـﻲ آﻨـﺪ ﺑـﺎ اﺳـﺘﻔﺎدﻩ از ﺗـﺎﺑﻊ‬ ‫)(‪ IsDate‬ﻣﻘﺪار ورودي را ﭼﻚ آﻨﻴﺪ و ﺑﻪ هﻤﻴﻦ ﺗﺮﺗﻴﺐ، ﻗﺎﻟﺐ هﺎي دﻳﮕﺮ.‬ ‫ﻣﺜﺎل زﻳﺮ ﭼﻚ ﻣﻲ آﻨﺪ آﻪ ﻣﻘﺪار ورودي آﺎرﺑﺮ ﺣﺘﻤﺎ ﺗﺎرﻳﺦ ﺑﺎﺷﺪ:‬ ‫)” ‪BDay =InputBox(“Please enter your birth date‬‬ ‫‪If IsDate(BDay) Then‬‬ ‫)”‪MsgBox(“Yes. This is a valid birth date‬‬ ‫‪Else‬‬ ‫)”‪MsgBox(“Please try again with a valid birth date‬‬ ‫‪End If‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٧‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)] ‪MsgBox(prompt [,buttons ][,title‬‬ ‫ﺗﺎﺑﻊ )(‪ ،MsgBox‬ﻳﻚ آﺎدر ﻣﺤﺎورﻩ را هﻤﺮاﻩ ﺑﺎ ﻳﻚ ﭘﻴﻐﺎم ﻧﻤﺎﻳﺶ دادﻩ و ﺗﺎ زﻣـﺎن ﺑـﺴﺘﻪ ﺷـﺪن آـﻪ‬ ‫ﺑﺎ آﻠﻴﻚ آﺎرﺑﺮ ﺑﺮ روي هﺮ ﻳﻚ از دآﻤﻪ هﺎي ﺁن اﻧﺠﺎم ﻣﻲ ﭘﺬﻳﺮد، ﺑﺮ روي ﺻﻔﺤﻪ ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ.‬ ‫ﭘﻴﻐـﺎﻣﻲ آـﻪ در اﻳـﻦ آـﺎدر ﻣﺤـﺎورﻩ ﻧﻤـﺎﻳﺶ دادﻩ ﺧﻮاهـﺪ ﺷـﺪ ﺑـﻪ ﻋﻨـﻮان اوﻟـﻴﻦ ﺁرﮔﻮﻣـﺎن و ﺑـﺎ ﻧـﺎم‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫‪ Prompt‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد.‬ ‫ﺳﺎدﻩ ﺗﺮﻳﻦ ﺷﻜﻞ اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺖ:‬ ‫)”!‪MsgBox(“Your Computer is running out of memory‬‬ ‫اﻳﻦ دﺳﺘﻮر ﻳﻚ ﭘﻴﻐﺎم را در ﻳﻚ آﺎدر ﻣﺤﺎورﻩ هﻤﺮاﻩ ﺑﺎ ﻳﻚ دآﻤﻪ ‪ OK‬ﻧﻤﺎﻳﺶ ﺧﻮاهﺪ داد.‬ ‫ﺗﺎﺑﻊ )(‪ MsgBox‬هﻤﭽﻨﻴﻦ ﻗﺎدر ﺑﻪ ﻧﻤﺎﻳﺶ دآﻤﻪ هﺎ و ﺁﻳﻜﻮن هﺎﻳﻲ ﻧﻴﺰ در آﺎدر ﻣﺤـﺎورﻩ ﺧـﻮد ﻣـﻲ‬ ‫ﺑﺎﺷﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻣﻘﺪاري ﻋﺪدي را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ آﻪ ﻣﻌﺮف ﻣﻘﺪار دآﻤﻪ اي اﺳـﺖ آـﻪ آـﺎرﺑﺮ ﺑـﺮ روي‬ ‫ﺁن آﻠﻴﻚ آﺮدﻩ.‬ ‫ﻣﻘﺎدﻳﺮ زﻳﺮ آﻠﻴﻪ ﻣﻘﺎدﻳﺮي هﺴﺘﻨﺪ آﻪ ﺁرﮔﻮﻣﺎن ‪ buttons‬ﻗﺎدر ﺑﻪ درﻳﺎﻓﺖ ﺁﻧﻬﺎﺳﺖ:‬ ‫ﻣﻘﺎدﻳﺮ دآﻤﻪ هﺎ در ﭘﺎراﻣﺘﺮ ‪ buttons‬از ﺗﺎﺑﻊ )(‪MsgBox‬‬ ‫ﺗﻨﻬﺎ دآﻤﻪ ‪ OK‬ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ.)ﻣﻘـﺪار ﭘـﻴﺶ‬ ‫‪ OKOnly‬ﻳﺎ 0‬ ‫ﻓﺮض(‬ ‫دآﻤﻪ هﺎي ‪ OK‬و ‪ Cancel‬ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ.‬ ‫‪ OKCancel‬ﻳﺎ 1‬ ‫دآﻤـ ـﻪ هـ ـﺎي ‪ Abort‬و ‪ Retry‬و ‪Ignore‬‬ ‫ـ‬ ‫ـ‬ ‫‪ AbortRetryIgnore‬ﻳﺎ 2‬ ‫ﻧﻤﺎﻳﺶ دادﻩ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫دآﻤــﻪ هــﺎي ‪ Yes‬و ‪ No‬و ‪ Cancel‬ﻧﻤــﺎﻳﺶ‬ ‫‪ YesNoCancel‬ﻳﺎ 3‬ ‫دادﻩ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫دآﻤﻪ هﺎي ‪ Yes‬و ‪ No‬را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫‪ YesNo‬ﻳﺎ 4‬ ‫دآﻤــﻪ هــﺎي ‪ Retry‬و ‪ Cancel‬را ﻧﻤــﺎﻳﺶ ﻣــﻲ‬ ‫‪RetryCancel‬‬ ‫دهﺪ.‬ ‫ﻣﻘﺎدﻳﺮ ﺁﻳﻜﻮن هﺎ در ﭘﺎراﻣﺘﺮ ‪ buttons‬از ﺗﺎﺑﻊ )(‪MsgBox‬‬ ‫ﭘﻴﻐﺎم ﺣﺴﺎس را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﺁﻳﻜﻮن‬ ‫‪ Critical‬ﻳﺎ 61‬ ‫ﻋﻼﻣﺖ ﺳﻮال را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﺁﻳﻜﻮن‬ ‫‪Question‬ﻳﺎ 23‬ ‫ﭘﻴﻐﺎم هﺸﺪار را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﺁﻳﻜﻮن‬ ‫‪ Exclamation‬ﻳﺎ 84‬ ‫ﭘﻴﻐﺎم اﻃﻼﻋﺎﺗﻲ را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﺁﻳﻜﻮن‬ ‫‪Information‬ﻳﺎ 46‬ ‫ﻣﻘﺎدﻳﺮ دآﻤﻪ هﺎي ﭘﻴﺶ ﻓﺮض در ﭘﺎراﻣﺘﺮ ‪ buttons‬از ﺗﺎﺑﻊ )(‪MsgBox‬‬ ‫اوﻟــﻴﻦ دآﻤــﻪ را ﺑــﻪ ﻋﻨــﻮان دآﻤــﻪ ﭘــﻴﺶ ﻓــﺮض‬ ‫1‪ DefaultButton‬ﻳﺎ 0‬ ‫اﻧﺘﺨﺎب ﻣﻲ آﻨﺪ.‬ ‫دوﻣـﻴﻦ دآﻤـﻪ را ﺑـﻪ ﻋﻨـﻮان دآﻤـﻪ ﭘـﻴﺶ ﻓـﺮض‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫2‪ DefaultButton‬ﻳﺎ 652‬ ‫اﻧﺘﺨﺎب ﻣﻲ آﻨﺪ.‬ ‫ﺳﻮﻣﻴﻦ دآﻤﻪ را ﺑـﻪ ﻋﻨـﻮان دآﻤـﻪ ﭘـﻴﺶ ﻓـﺮض‬ ‫3‪ DefaultButton‬ﻳﺎ 215‬ ‫اﻧﺘﺨﺎب ﻣﻲ آﻨﺪ.‬ ‫ﻣﻘﺎدﻳﺮ ﺷﺮﻃﻲ در ﭘﺎراﻣﺘﺮ ‪ buttons‬از ﺗﺎﺑﻊ )(‪MsgBox‬‬ ‫ﺗﺎ زﻣﺎﻧﻲ آﻪ آﺎرﺑﺮ ﺑﻪ آﺎدر ﻣﺤﺎورﻩ ﺟﻮاﺑﻲ ﻧﺪهﺪ‬ ‫‪ ApplicationModal‬ﻳﺎ 0‬ ‫ﻧﻤﻲ ﺗﻮاﻧﺪ ﺑﺮ روي هﻴﭽﻜﺪام از ﻓﺮم هﺎي ﺑﺮﻧﺎﻣﻪ‬ ‫ﺟﺎري ﺳﻮﻳﭻ آﻨﺪ.‬ ‫ﺗﺎ زﻣﺎﻧﻲ آﻪ آﺎرﺑﺮ ﺑﻪ آﺎدر ﻣﺤﺎورﻩ ﺟﻮاﺑﻲ ﻧﺪهﺪ‬ ‫‪ SystemModal‬ﻳﺎ 6904‬ ‫ﻧﻤﻲ ﺗﻮاﻧﺪ ﺑﻪ هﻴﭻ آﺪام از ﺑﺮﻧﺎﻣﻪ هﺎي در ﺣـﺎل‬ ‫اﺟﺮا ﺳﻮﻳﭻ آﻨﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٨‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﻣﻘﺎدﻳﺮ دآﻤﻪ هﺎ ﺑﻪ ﺷﻤﺎ اﻳﻦ اﻣﻜﺎن را ﻣﻲ دهﺪ آﻪ ﺗﻌﻴﻴﻦ آﻨﻴﺪ آﺪاﻣﻴﻚ از دآﻤﻪ هﺎ ﺑـﺮ روي آـﺎدر‬ ‫ﻣﺤﺎورﻩ ﻇﺎهﺮ ﺷﻮد.‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﺷﻤﺎ ﻧﻤﻲ ﺗﻮاﻧﻴﺪ ﻳﻚ ﻣﻘﺪار ﻣﻨﺤﺼﺮ ﺑﻪ ﻓﺮد ﺑﺮاي اﻳﻦ ﺁرﮔﻮﻣﺎن ﺗﻌﻴﻴﻦ آﻨﻴﺪ.‬ ‫زﻣﺎﻧﻲ آﻪ روﻳﺪادي اﺳﺘﺜﻨﺎﻳﻲ ﻳﺎ ﻏﻴـﺮ ﻋـﺎدي در وﻳﻨـﺪوز رخ دهـﺪ، ﺑـﻪ وﺳـﻴﻠﻪ ﺁﻳﻜـﻮن هـﺎ ﻧـﻮع اﻳـﻦ‬ ‫روﻳﺪاد ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد. اﻳﻦ روﻳـﺪاد ﻣﻤﻜـﻦ اﺳـﺖ ﺣـﺴﺎس، ﭘﺮﺳـﺸﻲ، هـﺸﺪار و ﻳـﺎ اﻃﻼﻋـﺎﺗﻲ‬ ‫ﺑﺎﺷﺪ.‬ ‫ﻣﻘﺎدﻳﺮ ﺁﻳﻜﻮن هﺎ ﻧﻮع ﺁﻳﻜﻮن ﻇﺎهﺮ ﺷﻮﻧﺪﻩ را ﺑﺮاي ﻣﺎ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﻨﺪ.‬ ‫ﻣﻘﺎدﻳﺮ ﭘﻴﺶ ﻓﺮض دآﻤﻪ هﺎ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﻨﺪ آﻪ آﺪام دآﻤﻪ در هﻨﮕﺎم ﻇـﺎهﺮ ﺷـﺪن آـﺎدر ﻣﺤـﺎورﻩ‬ ‫ﺑﻪ ﻋﻨﻮان دآﻤﻪ ﭘﻴﺶ ﻓﺮض اﻧﺘﺨﺎب ﺷﺪﻩ ﺑﺎﺷﺪ. در ﺻﻮرﺗﻲ آﻪ ﺗﻌﻴﻴﻦ ﻧﺸﻮد اوﻟﻴﻦ دآﻤﻪ از ﺳﻤﺖ‬ ‫ﭼﭗ ﺑﻪ ﻋﻨﻮان دآﻤﻪ ﭘﻴﺶ ﻓﺮض اﻧﺘﺨﺎب ﻣﻲ ﺷﻮد.‬ ‫ﻣﻘﺎدﻳﺮ ﺷﺮﻃﻲ ﻧﻴﺰ ﻧﻮع رﻓﺘﺎر آﺎدر ﻣﺤﺎورﻩ را ﺑﻪ ﻋﻜﺲ اﻟﻌﻤﻞ آﺎرﺑﺮ ﻣﺸﺨﺺ ﻣﻲ آﻨﻨﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ ،MsgBox‬ﻣﻘﺪاري از ﻧﻮع ‪ Integer‬را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ آﻪ ﻣﻌﻴﻦ ﻣﻲ آﻨـﺪ آـﺪام دآﻤـﻪ‬ ‫ﺗﻮﺳﻂ آﺎرﺑﺮ ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ. اﻳﻦ ﻣﻘﺎدﻳﺮ در ﺟﺪول زﻳﺮ ﻟﻴﺴﺖ ﺷﺪﻩ اﺳﺖ:‬ ‫ﻣﻘﺎدﻳﺮي آﻪ ﺗﺎﺑﻊ )(‪ MsgBox‬ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‬ ‫ﺗﻮﺿﻴﺤﺎت‬ ‫ﻣﻘﺪار‬ ‫دآﻤﻪ ‪ OK‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫‪ OK‬ﻳﺎ 1‬ ‫دآﻤﻪ ‪ Cancel‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫‪ Cancel‬ﻳﺎ 2‬ ‫دآﻤﻪ ‪ Abort‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫‪ Abort‬ﻳﺎ 3‬ ‫دآﻤﻪ ‪ Retry‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫‪ Retry‬ﻳﺎ 4‬ ‫دآﻤﻪ ‪ Ignore‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫‪ Ignore‬ﻳﺎ 5‬ ‫دآﻤﻪ ‪ Yes‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫‪ Yes‬ﻳﺎ 6‬ ‫دآﻤﻪ ‪ No‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫‪ No‬ﻳﺎ 7‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺑﺮاي ﻧﻤﺎﻳﺶ آﺎدر ﻣﺤﺎورﻩ اي ﺑﺎ دآﻤﻪ هﺎي ‪ OK‬و ‪ Cancel‬و ﺁﻳﻜﻮن ﭘﻴﻐﺎم هـﺸﺪار‬ ‫ﺑﻪ ﺻﻮرت زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ:‬ ‫_,”‪Res =MsgBox(“This operation may take several minutes‬‬ ‫)‪MsgBoxStyle.Exclamation +MsgBoxStyle.OKCancel‬‬ ‫ﻣﻘﺪاري آﻪ ﺗﻮﺳﻂ اﻳﻦ آﺎدر ﻣﺤﺎورﻩ ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﺪ ﺷﺪ، ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ ذآﺮ ﺷﺪﻩ در ﺟﺪول‬ ‫ﺑﺎﻻﺳﺖ آﻪ ﺑﺴﺘﻪ ﺑﻪ اﻧﺘﺨﺎب هﺮ ﻳﻚ از دآﻤﻪ هﺎي ‪ OK‬ﻳﺎ ‪ ،Cancel‬ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ 1 ﻳﺎ 2 ﺧﻮاهـﺪ‬ ‫ﺑﻮد.‬ ‫در ﻣﺜﺎل ﺑﻌﺪي ﻗﺼﺪ ﻇﺎهﺮ آﺮدن آﺎدر ﻣﺤﺎورﻩ اي ﺑﺎ دآﻤﻪ هﺎي ‪ Yes‬و ‪ No‬هﻤﺮاﻩ ﺑـﺎ ﺁﻳﻜـﻮن ﭘﻴﻐـﺎم‬ ‫ﺣﺴﺎس را دارﻳﻢ:‬ ‫_,”?‪Res =MsgBox(“Incomplete data.Would you like to retry‬‬ ‫)‪MsgBoxStyle.YesNo +MsgBoxStyle.Critical‬‬ ‫‪If Res =MsgBoxResult.Yes Then ‘user clicked Yes‬‬ ‫}‪{prompt again‬‬ ‫‪Else ‘user clicked No‬‬ ‫}‪{exit procedure‬‬ ‫‪Endif‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٩‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ ﻓﺎﻳﻞ هﺎ و ﭘﻮﺷﻪ هﺎ ﺳﺮ و آﺎر دارﻧﺪ )‪:(File and Folder Manipulation‬‬ ‫ﺗﻮاﺑﻊ زﻳﺮ ﺑﺮﺧﻲ از آﺎرهﺎي ﻣﺪﻳﺮﻳﺘﻲ را در راﺑﻄﻪ ﺑﺎ ﻓﺎﻳﻞ هﺎ و ﭘﻮﺷﻪ هﺎ هﻤﺎﻧﻨﺪ اﻧﺘﻘﺎل و ﺗﻐﻴﻴـﺮ ﻧـﺎم‬ ‫ﻓﺎﻳﻞ هﺎ، اﻳﺠﺎد ﭘﻮﺷﻪ ﺟﺪﻳﺪ، ﺣﺬف ﻓﺎﻳﻞ ﻳﺎ ﭘﻮﺷﻪ و … اﻧﺠﺎم ﻣﻲ دهﻨﺪ.‬ ‫ﻓﺮﻣﺎن هﺎي زﻳﺮ ﺑﺎ ﻣﺤﺘﻮﻳﺎت ﻓﺎﻳﻞ هﺎ آﺎري ﻧﺪاﺷﺘﻪ و اآﺜﺮا هﻤﺎﻧﻨﺪ ﻓﺮﻣﺎن هﺎي ﻣﺪﻳﺮﻳﺘﻲ ﻓﺎﻳﻞ هـﺎ و‬ ‫ﭘﻮﺷﻪ هﺎي ‪ DOS‬هﺴﺘﻨﺪ.‬ ‫)‪:GetAttr(pathname‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻣﻘﺪاري را از ﻧﻮع ‪ Integer‬ﺑﺮﮔﺸﺖ ﻣـﻲ دهـﺪ آـﻪ ﻧﻤﺎﻳـﺎﻧﮕﺮ ﺻـﻔﺖ ﻓﺎﻳـﻞ، داﻳﺮآﺘـﻮري ﻳـﺎ‬ ‫ﭘﻮﺷﻪ اي اﺳﺖ آﻪ ﻧﺎم ﺁن در ﺁرﮔﻮﻣﺎن ‪ pathname‬ﺁﻣﺪﻩ اﺳﺖ.‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ اﻳﻦ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮاﻧﺪ ﺑﺮﮔﺸﺖ دهﺪ در زﻳﺮ ﻟﻴﺴﺖ ﺷﺪﻩ اﺳﺖ:‬ ‫ﻣﻘﺎدﻳﺮي آﻪ ﺗﺎﺑﻊ )(‪ GetAttr‬ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‬ ‫ﺗﻮﺿﻴﺤﺎت‬ ‫ﻣﻘﺪار‬ ‫ﻧﺮﻣﺎل )هﻴﭻ ﺻﻔﺘﻲ ﻧﺪارد(‬ ‫‪ Normal‬ﻳﺎ 0‬ ‫ﻓﻘﻂ ﺧﻮاﻧﺪﻧﻲ‬ ‫‪ ReadOnly‬ﻳﺎ 1‬ ‫ﻣﺨﻔﻲ‬ ‫‪ Hidden‬ﻳﺎ 2‬ ‫ﺳﻴﺴﺘﻤﻲ‬ ‫‪ System‬ﻳﺎ 4‬ ‫ﺑﺮﭼﺴﺐ دراﻳﻮ‬ ‫‪ Volume‬ﻳﺎ 8‬ ‫داﻳﺮآﺘﻮري ﻳﺎ ﭘﻮﺷﻪ‬ ‫‪ Directory‬ﻳﺎ 61‬ ‫ﺁرﺷﻴﻮ )ﻓﺎﻳـﻞ در ﺁﺧـﺮﻳﻦ دﺳﺘﺮﺳـﻲ ﺗﻐﻴﻴـﺮ ﭘﻴـﺪا‬ ‫‪ Archive‬ﻳﺎ 23‬ ‫آﺮدﻩ اﺳﺖ(‬ ‫ﻧﻜﺎت ﻣﻬﻢ در اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ: ﺑﺮاي ﺗﺸﺨﻴﺺ اﻳﻨﻜـﻪ ﻋﺒـﺎرت ﻣـﺎ داراي ﭼـﻪ ﺻـﻔﺖ ﻳـﺎ ﺻـﻔﺎﺗﻲ‬ ‫اﺳﺖ از ﻋﻤﻠﮕﺮ ‪ AND‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.) ﻣﻤﻜﻦ اﺳﺖ ﻋﺒﺎرت داراي ﭼﻨﺪﻳﻦ ﺻﻔﺖ ﺑﺎﺷﺪ(‬ ‫اﮔﺮ ﻋﺒﺎرت ﻣﺎ هﻴﭽﮕﻮﻧﻪ ﺻﻔﺘﻲ ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ، ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ، ﺻﻔﺮ ﺧﻮاهﺪ ﺑﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل، ﺟﻬﺖ ﺗﺸﺨﻴﺺ اﻳﻨﻜﻪ ﻋﺒـﺎرت ﻣـﺎ داراي ﺻـﻔﺖ ﻓﻘـﻂ ﺧﻮاﻧـﺪﻧﻲ اﺳـﺖ ﻳـﺎ ﺧﻴـﺮ ﺑـﻪ‬ ‫ﺻﻮرت زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ:‬ ‫‪Result =GetAttr(FName) And FileAttribute.ReadOnly‬‬ ‫اﮔﺮ ﻋﺒﺎرت ‪ Fname‬داراي ﺻﻔﺖ ﻓﻘـﻂ ﺧﻮاﻧـﺪﻧﻲ ﺑﺎﺷـﺪ، ﻣﻘـﺪار ﺑﺮﮔـﺸﺘﻲ آـﻪ در ﻣﺘﻐﻴـﺮ ‪Result‬‬ ‫ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮد، 1 ﺧﻮاهﺪ ﺑﻮد در ﻏﻴﺮ اﻳﻨـﺼﻮرت ﺑـﺎ ﻓـﺮض اﻳﻨﻜـﻪ ﻋﺒـﺎرت ﻣـﺎ هـﻴﭻ ﺻـﻔﺖ دﻳﮕـﺮي‬ ‫ﻧﺪارد، ﻣﻘﺪار ‪ ،Result‬ﺻﻔﺮ ﺧﻮاهﺪ ﺑﻮد.‬ ‫در ﻣﺜﺎل زﻳﺮ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﻴﻢ آﻪ ﺁﻳﺎ ﻋﺒﺎرت ﻣﺎ داراي ﺻﻔﺖ ‪ Archive‬اﺳﺖ ﻳﺎ ﺧﻴﺮ:‬ ‫‪Result =GetAttr(FName)And FileAttribute.Archive‬‬ ‫اﮔﺮ ﻋﺒﺎرت، داراي ﻣﻘﺪار ‪ Archive‬ﺑﺎﺷﺪ، ﻣﻘﺪار ‪ 32 ،Result‬ﺧﻮاهﺪ ﺑﻮد.‬ ‫اﮔﺮ ﻋﺒﺎرت ﻣﺎ هﺮ دو ﻣﻘﺪار ﻓﻘﻂ ﺧﻮاﻧﺪﻧﻲ و ﺁرﺷﻴﻮ را دارا ﺑﺎﺷﺪ، ﻣﻘـﺪار ‪ ReadOnly‬و ‪Archive‬‬ ‫ﺑﺎ ﻳﻜﺪﻳﮕﺮ ﺟﻤﻊ ﻣﻲ ﺷﻮﻧﺪ، در ﻧﺘﻴﺠﻪ ‪33 ،Result‬ﺧﻮاهﺪ ﺷﺪ.‬ ‫از ﻋﻤﻠﮕﺮ ‪ OR‬ﻧﻴﺰ ﻣﻲ ﺗﻮاﻧﻴﺪ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫)‪SetAttr(pathname,attributes‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺻﻔﺘﻲ را ﺑﺮ روي ﻳﻚ ﻓﺎﻳﻞ ﻗﺮار ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،pathname‬ﻣﺴﻴﺮ ﻓﺎﻳﻠﻲ اﺳﺖ آﻪ ﻗﺮار اﺳﺖ ﺻﻔﺖ ﺑﺮ روي ﺁن اﻳﺠﺎد ﺷـﻮد و ﺁرﮔﻮﻣـﺎن‬ ‫‪ attributes‬ﻳﻚ ﻣﻘﺪار ﻋﺪدي اﺳﺖ آﻪ ﺑﺮاي ﺗﻌﻴﻴﻦ ﻧﻮع ﺻـﻔﺖ ﻳـﺎ ﺻـﻔﺖ هـﺎﻳﻲ اﺳـﺖ آـﻪ ﻗـﺮار‬ ‫اﺳﺖ ﺑﺮ روي ﻓﺎﻳﻞ اﻳﺠﺎد ﺷﻮد.‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ ﺁرﮔﻮﻣﺎن ‪ attributes‬ﻣﻲ ﺗﻮاﻧﺪ ﺑﭙﺬﻳﺮد در ﺟﺪول ﺗﺎﺑﻊ )(‪ GetAttr‬ذآﺮ ﺷﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٠١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﻧﻜﺎت ﻣﻬﻢ در اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ: از ﺁﻧﺠﺎ آﻪ اﻳﻦ ﺗﺎﺑﻊ ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ ﻧﺪارد، ﺁن را در ﻣﺘﻐﻴـﺮ ﻗـﺮار‬ ‫ﻧﺪهﻴﺪ.‬ ‫در اﻳﻦ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮان ﻳﻚ ﻳﺎ ﭼﻨﺪ ﺻﻔﺖ را هﻤﺰﻣﺎن اﻳﺠﺎد ﻳﺎ ﺣﺬف آﺮد.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫‪SetAttr "C:WindowsMyFile.txt", vbHidden And -vbReadOnly And vbArchive‬‬ ‫اﻳﻦ دﺳﺘﻮر ﺻﻔﺖ هﺎي ﻣﺨﻔﻲ و ﺁرﺷﻴﻮ را ﺑﺮ روي ﻓﺎﻳﻞ ‪ MyFile.txt‬اﻳﺠﺎد و ﺻﻔﺖ ﻓﻘﻂ ﺧﻮاﻧـﺪﻧﻲ‬ ‫ﺁن را ﺑﺮ ﻣﻲ دارد.‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ در ﺻﻮرﺗﻲ آﻪ ﻳﻚ ﺻﻔﺖ را ﺑﺮاي ﻳﻚ ﻓﺎﻳﻞ ﺗﻌﻴـﻴﻦ ﻣـﻲ آﻨﻴـﺪ ﺻـﻔﺖ ﻳـﺎ ﺻـﻔﺎت‬ ‫ﻗﺒﻠﻲ ﻓﺎﻳﻞ ﺣﺬف ﻣﻲ ﺷﻮﻧﺪ.‬ ‫ﺑﻪ ﻣﺜﺎل زﻳﺮ دﻗﺖ آﻨﻴﺪ:‬ ‫‪If GetAttr(file_name) And FileAttribute.Hidden Then‬‬ ‫)‪SetAttr(file_name, GetAttr(file_name)– FileAttribute..Hidden‬‬ ‫‪End If‬‬ ‫در اﻳﻦ ﻣﺜﺎل، اﺑﺘﺪا ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗـﺎﺑﻊ )(‪ GetAttr‬ﭼـﻚ ﻣـﻲ ﺷـﻮد آـﻪ ﻓﺎﻳـﻞ ﻣـﻮرد ﻧﻈـﺮ ﻣـﺎ داراي‬ ‫ﺻﻔﺖ ﻣﺨﻔﻲ اﺳﺖ ﻳﺎ ﺧﻴﺮ، اﮔﺮ داراي ﺻﻔﺖ ﻣﺨﻔﻲ ﺑﺎﺷﺪ ﺻـﻔﺖ ﻣﺨﻔـﻲ ﺁن ﺑـﺎ اﺳـﺘﻔﺎدﻩ از ﺗـﺎﺑﻊ‬ ‫)(‪ SetAttr‬ﺑﺮداﺷﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫هﻤﭽﻨﻴﻦ ﻣﻲ ﺗﻮان ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ MsgBox‬در ﻣﻮرد ﺣﺬف ﺻﻔﺖ ﻓﺎﻳﻞ ﺗﺎﻳﻴﺪ ﮔﺮﻓﺖ:‬ ‫‪If GetAttr(file_name) And FileAttribute.ReadOnly Then‬‬ ‫_ ,”?‪reply=MsgBox(“This is a read-only file.Delete it anyway‬‬ ‫)‪MsgBoxStyle.YesNo‬‬ ‫‪If reply=MsgBoxResult.Yes Then‬‬ ‫)‪SetAttr(file_name, GetAttr(file_name) - FileAttribute.ReadOnly‬‬ ‫)‪Kill(file_name‬‬ ‫‪End If‬‬ ‫‪Else‬‬ ‫)‪Kill(file_name‬‬ ‫‪End If‬‬ ‫در اﻳﻦ ﻣﺜﺎل، ﻓﺎﻳﻞ در ﻣﻮرد داﺷﺘﻦ ﺻﻔﺖ ﻓﻘﻂ ﺧﻮاﻧﺪﻧﻲ ﭼﻚ ﻣﻲ ﺷﻮد و در ﺻـﻮرت داﺷـﺘﻦ ﺁن ﺑـﺎ‬ ‫ﭘﺮﺳﺸﻲ از آﺎرﺑﺮ در ﻣﻮرد ﺣﺬف ﺁن ﺗﺎﻳﻴﺪ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫)‪Kill(pathname‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻓﺎﻳﻞ ﻳﺎ ﻓﺎﻳﻞ هﺎﻳﻲ را آﻪ ﻣﺴﻴﺮ و ﻧﺎم ﺁﻧﻬﺎ در ﺁرﮔﻮﻣﺎن ‪ pathname‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد ﭘﺎك‬ ‫ﻣﻲ آﻨﺪ.‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﻓﺎﻳﻞ هﺎي ﭘﺎك ﺷﺪﻩ ﺑﻪ ﺳﻄﻞ زﺑﺎﻟـﻪ وﻳﻨـﺪوز ﻣﻨﺘﻘـﻞ ﻧﻤـﻲ ﺷـﻮﻧﺪ و ﺑـﺮاي‬ ‫هﻤﻴﺸﻪ ﭘﺎك ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: در ﺻﻮرﺗﻲ آﻪ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ FileCopy‬ﻓﺎﻳﻠﻲ را ﺑﻪ ﺳﻄﻞ زﺑﺎﻟﻪ وﻳﻨـﺪوز اﻧﺘﻘـﺎل‬ ‫دهﻴﺪ، ﻓﺎﻳﻞ ﻣﻨﺘﻘﻞ ﺷﺪﻩ در ﭘﻨﺠﺮﻩ ﺳﻄﻞ زﺑﺎﻟﻪ ﻇﺎهﺮ ﺧﻮاهـﺪ ﺷـﺪ اﻣـﺎ ﺷـﻤﺎ ﻗـﺎدر ﺑـﻪ ﺑﺎزﻳـﺎﺑﻲ ﺁن‬ ‫ﻧﺨﻮاهﻴﺪ ﺑﻮد.‬ ‫هﻤﭽﻨﻴﻦ ﺷﻤﺎ در اﻳﻦ ﺗﺎﺑﻊ ﻗﺎدر ﺑﻪ اﺳﺘﻔﺎدﻩ از آﺎراآﺘﺮهﺎي ﺟﺎﻧﺸﻴﻨﻲ هﺴﺘﻴﺪ. )* ﻣﻌﺮف هﻤﻪ( و‬ ‫)؟ ﻣﻌﺮف ﻳﻚ آﺎراآﺘﺮ(‬ ‫اﮔﺮ ﻓﺎﻳﻠﻲ آﻪ ﻧﺎم ﺁن در ﺁرﮔﻮﻣﺎن ‪ pathname‬ذآﺮ ﻣـﻲ ﺷـﻮد وﺟـﻮد ﻧﺪاﺷـﺘﻪ ﺑﺎﺷـﺪ، ﻳـﻚ ﺧﻄـﺎي‬ ‫‪) RunTime‬زﻣﺎن اﺟﺮا ( اﺗﻔﺎق ﻣﻲ اﻓﺘﺪ.‬ ‫ﺳﻌﻲ آﻨﻴﺪ از اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ:‬ ‫‪Try‬‬ ‫)”‪Kill(“C:Log.txt‬‬ ‫‪Catch exc As Exception‬‬ ‫‪End Try‬‬ ‫در اﻳﻦ ﻣﺜﺎل ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﻌﺮﻳﻒ ﺳـﺎﺧﺘﺎر ‪ Error‬در ﺑﺮﻧﺎﻣـﻪ ﺑـﻪ وﺳـﻴﻠﻪ ‪ ،Try-Catch‬از رخ دادن‬ ‫ﺧﻄﺎي زﻣﺎن اﺟﺮا آﻪ ﻣﻤﻜﻦ اﺳﺖ ﺑﻪ دﻟﻴـﻞ وﺟـﻮد ﻧﺪاﺷـﺘﻦ ﻓﺎﻳـﻞ ‪ Log.txt‬در ﻣـﺴﻴﺮ ذآـﺮ ﺷـﺪﻩ‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫١١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫اﻳﺠﺎد ﺷﻮد ﻳﺎ هﺮ دﻟﻴﻞ دﻳﮕﺮي آﻪ ﻣﻤﻜﻦ اﺳﺖ از ﺣﺬف ﻓﺎﻳﻞ ﺟﻠﻮﮔﻴﺮي آﻨﺪ، ﺟﻠـﻮﮔﻴﺮي ﺷـﺪﻩ و در‬ ‫ﺻﻮرت رخ دادن ﺧﻄﺎ، آﻨﺘﺮل ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺧﻂ ﺑﻌﺪ ﻣﻨﺘﻘﻞ ﻣﻲ ﺷﻮد.‬ ‫)‪FileDateTime(pathname‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﺎرﻳﺦ و زﻣﺎن اﻳﺠﺎد ﻳﻚ ﻓﺎﻳـﻞ ﻳـﺎ ﺗـﺎرﻳﺦ و زﻣـﺎن ﺁﺧـﺮﻳﻦ زﻣـﺎﻧﻲ آـﻪ ﻓﺎﻳـﻞ ﺗﻐﻴـﺮ ﭘﻴـﺪا آـﺮدﻩ و‬ ‫وﻳﺮاﻳﺶ ﺷﺪﻩ اﺳﺖ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫))”‪Console.WriteLine(FileDateTime(“myDocument.txt‬‬ ‫ﺗﺎرﻳﺦ و زﻣﺎن ﺑﺮﮔﺸﺘﻲ ﻓﺮﺿﺎ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺧﻮاهﺪ ﺑﻮد:‬ ‫”‪“21/11/01 14:13:02 PM‬‬ ‫)‪FileLen(pathname‬‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ ﺗﺎﺑﻊ، ﻋﺪدي از ﻧـﻮع ‪ Long Integer‬ﺧﻮاهـﺪ ﺑـﻮد آـﻪ ﻣﻴـﺰان ﺣﺠـﻢ ﻓـﺎﻳﻠﻲ را‬ ‫ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ ﻧﺎم ﺁن در ﺁرﮔﻮﻣﺎن ‪ pathname‬ﺁﻣﺪﻩ اﺳﺖ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)”‪MsgBox(“The file contains” & FileLen(“.docs myDocument.txt”) & “bytes‬‬ ‫ﻣﻴﺰان ﺣﺠﻢ ﻓﺎﻳﻞ ﺗﻌﻴﻴﻦ ﺷﺪﻩ در آﺎدر ﻣﺤﺎورﻩ ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ.‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: ﺗﺎﺑﻊ )(‪ FileLen‬ﺑـﺎ ﺗـﺎﺑﻊ )(‪) LOF‬آـﻪ ﺣﺠـﻢ ﻓـﺎﻳﻠﻲ را آـﻪ هـﻢ اآﻨـﻮن ﺑـﺎز اﺳـﺖ ﺑﺮﻣـﻲ‬ ‫ﮔﺮداﻧــﺪ( ﺗﻔــﺎوت دارد. ﺟﻬــﺖ اﻃﻼﻋــﺎت ﺑﻴــﺸﺘﺮ، ﺗﻮﺿــﻴﺤﺎت ﺗــﺎﺑﻊ )(‪ LOF‬را آــﻪ در ﮔــﺮوﻩ ﺗﻮاﺑــﻊ‬ ‫ورودي/ﺧﺮوﺟﻲ ﻓﺎﻳﻞ هﺎ )‪ (File I/O‬دﺳﺘﻪ ﺑﻨﺪي ﺷﺪﻩ اﺳﺖ ﺑﺒﻴﻨﻴﺪ.‬ ‫)‪MkDir(path‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﭘﻮﺷﻪ )داﻳﺮآﺘﻮري( ﺟﺪﻳﺪ را اﻳﺠﺎد ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،path‬ﻧﺎم ﭘﻮﺷﻪ و ﻣﺴﻴﺮي اﺳﺖ آﻪ ﻗﺼﺪ اﻳﺠﺎد ﺁن را دارﻳﻢ.‬ ‫ﺑﻪ ﻣﺜﺎل زﻳﺮ ﺗﻮﺟﻪ آﻨﻴﺪ:‬ ‫)”‪MkDir(“C:Users New User‬‬ ‫اﻳﻦ دﺳﺘﻮر، ﭘﻮﺷﻪ اي ﺟﺪﻳﺪ ﺑﻪ ﻧـﺎم ‪ New Users‬در ﭘﻮﺷـﻪ ‪ Users‬اﻳﺠـﺎد ﻣـﻲ آﻨـﺪ. )اﻟﺒﺘـﻪ اﮔـﺮ‬ ‫ﭘﻮﺷﻪ ‪ Users‬وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﺪ.(‬ ‫هﻤﭽﻨﻴﻦ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﻪ ﻳﻚ ﻣﺴﻴﺮ ﻳﺎ ﭘﻮﺷﻪ دﻟﺨﻮاﻩ ﺳﻮﻳﭻ آﺮدﻩ و ﭘﻮﺷﻪ هﺎي ﺧﻮد را در ﺁﻧﺠـﺎ‬ ‫اﻳﺠﺎد آﻨﻴﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)”:‪ChDrive(“C‬‬ ‫)”:‪ChDir(“C‬‬ ‫)”‪MkDir(“Users‬‬ ‫)”‪ChDir(“Users‬‬ ‫)”‪MkDir(“New User‬‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: ﺣﺘﻤﺎ از ﺳﺎﺧﺘﺎر ‪ Try-Catch‬در ﺳﺎﺧﺖ ﭘﻮﺷﻪ هﺎ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ ﭼﻮن در ﺻـﻮرﺗﻲ آـﻪ‬ ‫ﭘﻮﺷﻪ اي آﻪ ﻗﺼﺪ اﻳﺠﺎد ﺁن را دارﻳﺪ در ﻣﺴﻴﺮ ذآﺮ ﺷﺪﻩ وﺟﻮد داﺷﺘﻪ ﺑﺎﺷـﺪ، ﺧﻄـﺎﻳﻲ رخ ﺧﻮاهـﺪ‬ ‫داد. )اﻟﺒﺘﻪ اﮔﺮ ﭘﻮﺷﻪ وﺟﻮد داﺷﺖ، ﻣﻲ ﺗﻮاﻧﻴﺪ ﺁن را ﺣﺬف و اﻗﺪام ﺑﻪ اﻳﺠﺎد ﭘﻮﺷﻪ ي ﺟﺪﻳﺪ آﻨﻴﺪ(‬ ‫)‪RmDir(path‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺑﺮاي ﺣﺬف ﭘﻮﺷﻪ ﻳﺎ داﻳﺮآﺘﻮري آﻪ ﻣﺴﻴﺮ و ﻧﺎم ﺁن در ﺁرﮔﻮﻣﺎن ‪ Path‬ﺁﻣـﺪﻩ اﺳـﺖ ﺑـﻪ آـﺎر‬ ‫ﻣﻲ رود.‬ ‫ﻧﻜﺎت ﻣﻬﻢ در اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ: ﺁرﮔﻮﻣﺎن ‪ Path‬ﻧﻤﻲ ﺗﻮاﻧـﺪ داراي آﺎراآﺘﺮهـﺎي ﺟﺎﻧـﺸﻴﻨﻲ )* و‬ ‫؟( ﺑﺎﺷﺪ. ﺑﻪ ﻋﺒﺎرت دﻳﮕﺮ ﺷﻤﺎ ﻧﻤﻲ ﺗﻮاﻧﻴﺪ ﭼﻨﺪﻳﻦ ﭘﻮﺷﻪ را ﺑـﺎ ﻳـﻚ ﺑـﺎر ﻓﺮاﺧـﻮاﻧﻲ اﻳـﻦ ﺗـﺎﺑﻊ ﺣـﺬف‬ ‫آﻨﻴﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٢١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﺑﺮاي ﺣﺬف ﭘﻮﺷﻪ، ﺑﺎﻳﺪ دو ﺷﺮط زﻳﺮ ﺑﺮﻗﺮار ﺑﺎﺷﺪ:‬ ‫١( ﭘﻮﺷﻪ ﺧﺎﻟﻲ ﺑﺎﺷﺪ. ٢( ﭘﻮﺷﻪ ﺟﺎري ﻧﺒﺎﺷﺪ.‬ ‫در ﺻﻮرت رﻋﺎﻳﺖ ﻧﻜﺮدن هﺮ ﻳﻚ از ﻣﻮارد ﻓﻮق، ﻳﻚ ﺧﻄﺎي زﻣﺎن اﺟﺮا اﺗﻔﺎق ﻣﻲ اﻓﺘﺪ.‬ ‫ﺑﺮاي ﺣﺬف ﭘﻮﺷﻪ اي آﻪ داراي ﺗﻌﺪادي ﻓﺎﻳـﻞ اﺳـﺖ، اﺑﺘـﺪا ﺑـﺎ ﺗـﺎﺑﻊ )(‪ Kill‬ﻓﺎﻳـﻞ هـﺎي درون ﺁن را‬ ‫ﺣﺬف و ﺳﭙﺲ ﺗﺎﺑﻊ ‪ RmDir‬را ﻓﺮاﺧﻮاﻧﻲ آﻨﻴـﺪ. ﻋـﻼوﻩ ﺑـﺮ ﺁن اﮔـﺮ ﭘﻮﺷـﻪ ي ﺷـﻤﺎ داراي ﺗﻌـﺪادي‬ ‫زﻳﺮﭘﻮﺷﻪ ﻧﻴﺰ ﺑﺎﺷﺪ، ﺑﺎﻳﺪ ﺁﻧﻬﺎ را هﻢ ﻗﺒﻞ از ﺣﺬف ﭘﻮﺷﻪ ي اﺻﻠﻲ ﺣﺬف آﻨﻴﺪ.‬ ‫ﻓﺮﻣﺎن زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)”‪RmDir(“C:Users‬‬ ‫در ﺻﻮرﺗﻲ آﻪ ﭘﻮﺷﻪ ي ‪ Users‬داراي زﻳﺮﭘﻮﺷـﻪ اي ﺑـﻪ ﻧـﺎم ‪ New User‬ﺑﺎﺷـﺪ، ﺧﻄـﺎﻳﻲ اﺗﻔـﺎق‬ ‫ﻣﻲ اﻓﺘﺪ.‬ ‫ﭘﺲ ﻓﺮﻣﺎن ﻓﻮق را ﺑﻪ ﺻﻮرت زﻳﺮ اﺻﻼح ﻣﻲ آﻨﻴﻢ:‬ ‫)”‪RmDir(“C:Users New User‬‬ ‫)”‪RmDir(“C:Users‬‬ ‫)‪ChDir(path‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﭘﻮﺷﻪ )داﻳﺮآﺘﻮري( ﺟﺎري را ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺑﺮاي ﺳﻮﻳﭻ ﺑﻪ ﭘﻮﺷﻪ ‪ C:Windows‬ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ:‬ ‫)”‪ChDir(“C:Windows‬‬ ‫ﻧﻜﺎت ﻣﻬﻢ: اﮔﺮ در ﺁرﮔﻮﻣﺎن ‪ path‬اﻳﻦ ﺗـﺎﺑﻊ از ﺁوردن ﻧـﺎم دراﻳـﻮ ﺧـﻮدداري ﺷـﻮد، ﺗـﺎﺑﻊ )(‪ChDir‬‬ ‫ﺗﻼش ﻣﻲ آﻨﺪ ﺗﺎ در دراﻳﻮ ﺟﺎري ﺑﻪ ﭘﻮﺷﻪ اي آـﻪ ﻧـﺎم ﺁن در در ﺁرﮔﻮﻣـﺎن ‪ path‬ﻣـﺸﺨﺺ ﺷـﺪﻩ‬ ‫ﺳﻮﻳﭻ آﻨﺪ و اﮔﺮ ﭘﻮﺷﻪ وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ، ﻳﻚ ﺧﻄﺎ رخ ﻣﻲ دهﺪ و ﻣﺴﻴﺮ ﺟﺎري ﺗﻐﻴﻴﺮ ﭘﻴﺪا ﻧﻤﻲ‬ ‫آﻨﺪ.‬ ‫ﺗﻮﺟﻪ: ﺗﺎﺑﻊ )(‪ ،ChDir‬ﭘﻮﺷﻪ ﺟﺎري را ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ ﻧﻪ دراﻳﻮ ﺟﺎري را.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔﺮ دراﻳﻮ ﺟﺎري ):‪ (C‬ﺑﺎﺷﺪ، دﺳﺘﻮر زﻳﺮ ﭘﻮﺷﻪ ﺟﺎري را ﺑـﻪ ﭘﻮﺷـﻪ دﻳﮕـﺮي در دراﻳـﻮ‬ ‫):‪ (D‬ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ اﻣﺎ دراﻳﻮ ):‪ (C‬ﺑﻪ ﻋﻨﻮان دراﻳﻮ ﺟﺎري ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ:‬ ‫”‪ChDir “D:TMP‬‬ ‫ﺑﺮاي ﺗﻐﻴﻴﺮ دراﻳﻮ ﺟﺎري از ﺗـﺎﺑﻊ )(‪ ChDrive‬آـﻪ ﺑـﻪ ﻋﻨـﻮان ﺗـﺎﺑﻊ ﺑﻌـﺪي ﺗﻮﺿـﻴﺢ دادﻩ ﺷـﺪﻩ اﺳـﺖ‬ ‫اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﺷﻤﺎ هﻤﭽﻨﻴﻦ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻧﺎم هﺎي ﻧﺴﺒﻲ را ﺑﻪ ﻋﻨﻮان ﻧﺎم ﭘﻮﺷﻪ ﺑﻪ آﺎر ﺑﺒﺮﻳﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل دﺳﺘﻮر )”..“(‪ ChDir‬ﭘﻮﺷﻪ ﺟﺎري را ﻳﻚ ﻣﺮﺣﻠﻪ ﺑﻪ ﺑﺎﻻ در ﭘﻮﺷﻪ اﺻﻠﻲ اﻧﺘﻘﺎل ﻣﻲ‬ ‫ده ـﺪ در ﺻ ـﻮرﺗﻲ آ ـﻪ دﺳ ـﺘﻮر )”‪ ،ChDir(“..MyFiles‬ﭘﻮﺷ ـﻪ ‪ MyFiles‬را در ﭘﻮﺷ ـﻪ اﺻ ـﻠﻲ ﺑ ـﻪ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ﻋﻨﻮان ﭘﻮﺷﻪ ﺟﺎري در ﻧﻈﺮ ﻣﻲ ﮔﻴﺮد.‬ ‫ﺗﻮﺟﻪ: هﻢ ﭘﻮﺷﻪ ي ﺟﺎري و هﻢ ﭘﻮﺷﻪ ي ‪ ،MyFiles‬دو زﻳﺮﭘﻮﺷﻪ در ﻳﻚ ﭘﻮﺷﻪ اﺻﻠﻲ هﺴﺘﻨﺪ.‬ ‫)‪ChDrive(drive‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ دراﻳﻮ ﺟﺎري را ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ. هﻤﺎﻧﻨﺪ: )”:‪ChDrive(“D‬‬ ‫اﻳﻦ دﺳﺘﻮر، دراﻳﻮ ﺟﺎري را ﺑﻪ دراﻳﻮ ‪ D‬ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ.‬ ‫ﻧﻜﺎت ﻣﻬﻢ: دراﻳﻮي آﻪ ﻧﺎم ﺁن در ﺁرﮔﻮﻣﺎن ‪ drive‬ذآﺮ ﻣﻲ ﺷﻮد ﺑﺎﻳﺪ وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﺪ.‬ ‫اﮔﺮ در ﺁرﮔﻮﻣﺎن ‪ drive‬ﻧﺎم ﭼﻨﺪﻳﻦ دراﻳﻮ ذآﺮ ﺷﻮد، ﻧﺎم اوﻟﻴﻦ دراﻳﻮ ﺟﻬﺖ ﺗﻐﻴﻴﺮ در ﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﻣـﻲ‬ ‫ﺷﻮد.‬ ‫)] ‪CurDir([drive‬‬ ‫هﻨﮕﺎﻣﻲ آﻪ اﻳﻦ ﺗﺎﺑﻊ، ﺑﺪون ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ drive‬ﻓﺮاﺧﻮاﻧﻲ ﺷﻮد، ﻧﺎم ﭘﻮﺷﻪ ﺟﺎري را در دراﻳـﻮ‬ ‫ﺟﺎري ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺑﺮاي اﻳﻨﻜﻪ ﺑﻔﻬﻤﻴﺪ آﻪ آﺪام ﭘﻮﺷﻪ در دراﻳﻮ دﻳﮕﺮي ﭘﻮﺷﻪ ﺟـﺎري اﺳـﺖ، ﻧـﺎم دراﻳـﻮ را در ﺁرﮔﻮﻣـﺎن‬ ‫‪ drive‬ذآﺮ آﻨﻴﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٣١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔﺮ ﺷﻤﺎ در ﻳـﻚ ﭘﻮﺷـﻪ در دراﻳـﻮ ):‪ (C‬ﺑﺎﺷـﻴﺪ، دﺳـﺘﻮر )(‪ CDir =CurDir‬ﻣـﺴﻴﺮ‬ ‫ﭘﻮﺷﻪ ﺟﺎري را در دراﻳﻮ ﺟﺎري ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺑﺮاي اﻳﻨﻜﻪ ﺑﻔﻬﻤﻴﻢ آﻪ ﭘﻮﺷﻪ ﺟﺎري در ﻳﻚ دراﻳﻮ دﻳﮕﺮ ﻣـﺜﻼ ):‪ (D‬ﭼﻴـﺴﺖ، ﺗـﺎﺑﻊ )(‪ CurDir‬را ﺑـﻪ‬ ‫ﺻﻮرت زﻳﺮ ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ آﻨﻴﻢ:‬ ‫)”‪DDir =CurDir(“D‬‬ ‫)]] ‪Dir([pathname [,attributes‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، دو ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري را درﻳﺎﻓـﺖ آـﺮدﻩ و ﻳـﻚ ﻣﻘـﺪار از ﻧـﻮع رﺷـﺘﻪ اي را آـﻪ ﻧـﺎم ﻓﺎﻳـﻞ ﻳـﺎ‬ ‫ﭘﻮﺷﻪ اي اﺳﺖ آﻪ ﺑﺎ ﺁرﮔﻮﻣﺎن ‪) pathname‬ﻣـﺴﻴﺮ ﻓﺎﻳـﻞ ﻳـﺎ ﭘﻮﺷـﻪ( ﻳـﺎ ‪) attributes‬ﺻـﻔﺖ ﻳـﺎ‬ ‫ﺻﻔﺎت ﻓﺎﻳﻞ( ﻣﻄﺎﺑﻘﺖ دارد، ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﻧﻜﺎت ﻣﻬﻢ در اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ:‬ ‫در اﻳﻦ ﺗﺎﺑﻊ ﻣﺠﺎز ﺑﻪ اﺳﺘﻔﺎدﻩ از ﻋﻼﻣﺖ هﺎي ﺟﺎﻳﮕﺰﻳﻦ هﺴﺘﻴﺪ.)* و ؟(‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫‪Dim sFile As String‬‬ ‫)"‪sFile = Dir("C:Windows‬‬ ‫‪Do Until sFile = vbNullString‬‬ ‫‪Console.WriteLn sFile‬‬ ‫)(‪sFile = Dir‬‬ ‫‪Loop‬‬ ‫در اﻳﻦ ﻣﺜﺎل، آﻠﻴﻪ ﻓﺎﻳﻞ هﺎﻳﻲ آﻪ در ﭘﻮﺷﻪ ‪ Windows‬وﺟﻮد دارﻧﺪ)در ﭘﻮﺷـﻪ اﺻـﻠﻲ ‪Windows‬‬ ‫ﻧﻪ در زﻳﺮ ﭘﻮﺷﻪ هﺎي ﺁن( ﭼﺎپ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫اﮔﺮ هﻴﭻ ﻓﺎﻳﻠﻲ ﺑﺎ ﺁرﮔﻮﻣﺎن هﺎي ذآﺮ ﺷﺪﻩ در ﺗﺎﺑﻊ )(‪ Dir‬ﺻﺪق ﻧﻜﻨﺪ، ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ، ﻳـﻚ ﻣﻘـﺪار‬ ‫ﺧﺎﻟﻲ ﺧﻮاهﺪ ﺑﻮد.‬ ‫دوﻣﻴﻦ ﺁرﮔﻮﻣﺎن، ﻳﻚ ﻣﻘﺪار ﻋﺪدي ﻳﺎ ﺛﺎﺑﺖ اﺳـﺖ آـﻪ در ﺗﻮﺿـﻴﺤﺎت ﺗـﺎﺑﻊ )(‪ SetAttr‬ﺁﻣﺪﻧـﺪ و ﻣـﻲ‬ ‫ﺗﻮاﻧﺪ ﻳﻚ ﻣﻘﺪار ﻳﺎ ﺑﻴﺸﺘﺮ ﺑﺎﺷﺪ.‬ ‫در ﺻﻮرﺗﻲ آﻪ از ذآﺮ اﻳﻦ ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ﺧﻮدداري ﺷﻮد، ﺗﻨﻬﺎ ﻓﺎﻳﻞ هﺎي ‪) Normal‬ﻓﺎﻳـﻞ هـﺎي‬ ‫ﺑﺪون ﺻﻔﺖ( ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫ﻳﻜﻲ از آﺎرﺑﺮدهﺎي اﻳﻦ ﺗﺎﺑﻊ ﺑﺮاي ﺗﻌﻴﻴﻦ وﺟﻮد ﻳﻚ ﻓﺎﻳﻞ ﻳﺎ ﭘﻮﺷﻪ در ﻣﺴﻴﺮ ﻣﺸﺨﺺ ﺷﺪﻩ اﺳﺖ.‬ ‫ﺑﻪ ﻓﺮﻣﺎن زﻳﺮ ﺗﻮﺟﻪ آﻨﻴﺪ:‬ ‫)”‪OCXFile =Dir(“C:WINDOWS SYSTEM MSCOMCTL.OCX‬‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ ﻓﺮﻣﺎن در ﺻﻮرت وﺟﻮد ﻓﺎﻳﻞ ‪ MSCOMCTL.OCX‬در ﻣﺴﻴﺮ ذآﺮ ﺷﺪﻩ، هﻤﺎن‬ ‫ﻧﺎم ﻓﺎﻳﻞ اﺳﺖ در ﻏﻴﺮ اﻳﻨﺼﻮرت ﻳﻚ ﻣﻘﺪار ﺗﻬﻲ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫در اﻳﻦ ﻣﺜﺎل ﻣﻲ ﺧﻮاهﻴﻢ ﺑﺪاﻧﻴﻢ آﻪ ﭼﻨﺪ ﻓﺎﻳﻞ ﺑﺎ ﭘﺴﻮﻧﺪ ‪ DLL‬در ﻣﺴﻴﺮي آﻪ ﻣﺸﺨﺺ ﻣﻲ آﻨـﻴﻢ‬ ‫وﺟﻮد دارد:‬ ‫‪Dim DLLFile As String‬‬ ‫‪Dim DLLFiles As Integer‬‬ ‫)”‪DLLFile =Dir(“C:WINNT SYSTEM *.DLL‬‬ ‫1+ ‪If DLLFile <>“” Then DLLFiles =DLLFiles‬‬ ‫”“>< ‪While DLLFile‬‬ ‫)(‪DLLFile =Dir‬‬ ‫1+ ‪DLLFiles =DLLFiles‬‬ ‫‪End While‬‬ ‫)‪MsgBox(DLLFiles‬‬ ‫در اﻳﻦ دﺳﺘﻮرات، ﺗﺎﺑﻊ )(‪ Dir‬اﺑﺘﺪا ﺑﺎ ﻳﻜﻲ از ﺁرﮔﻮﻣﺎن هﺎﻳﺶ ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ ﺷﻮد.‬ ‫اﮔﺮ ﻳﻚ ﻓﺎﻳﻞ ‪ DLL‬در ﻣﺴﻴﺮ ﻣﺸﺨﺺ ﺷﺪﻩ وﺟﻮد داﺷﺖ، ﻧﺎم ﺁن ﺑﺮﮔـﺸﺖ دادﻩ ﻣـﻲ ﺷـﻮد و ﺗـﺎﺑﻊ‬ ‫ﻣﺠﺪدا ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ ﺷﻮد اﻣﺎ اﻳﻦ ﺑﺎر ﺑﺪون ﺁرﮔﻮﻣﺎن.‬ ‫هﺮ ﺑﺎر آﻪ ﺗﺎﺑﻊ، ﻧﺎم ﻳﻚ ﻓﺎﻳﻞ ‪ DLL‬را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ ﻳﻚ واﺣﺪ ﺑﻪ ﻣﺘﻐﻴﺮ ‪ DLLFiles‬اﺿـﺎﻓﻪ ﻣـﻲ‬ ‫ﺷﻮد. اﻳﻦ آﺎر ﺑﺮاي ﺗﻤﺎﻣﻲ ﻓﺎﻳﻞ هﺎي ‪ DLL‬در ﻣﺴﻴﺮ ﻣـﺸﺨﺺ ﺷـﺪﻩ اداﻣـﻪ ﻣـﻲ ﻳﺎﺑـﺪ و در ﺁﺧـﺮ،‬ ‫ﻣﻘﺪار ﻣﺘﻐﻴﺮ ‪ ،DLLFiles‬ﺗﻌﺪاد ﻓﺎﻳﻞ هﺎي ﻣﺸﺨﺺ ﺷﺪﻩ در ﻣﺴﻴﺮ ﺗﻌﻴﻴﻦ ﺷﺪﻩ را دارا ﻣﻲ ﺑﺎﺷﺪ.‬ ‫ﺧﻮب ﻣﻲ ﺧﻮاهﻴﻢ ﺗﺎﺑﻊ را ﮔﺴﺘﺮش دهﻴﻢ و ﻓﻘﻂ ﻓﺎﻳﻞ هﺎي ‪ DLL‬اي را ﺟـﺴﺘﺠﻮ آﻨـﻴﻢ آـﻪ داراي‬ ‫ﺻﻔﺖ ‪) Hidden‬ﻣﺨﻔﻲ( هﺴﺘﻨﺪ.‬ ‫ﭘﺲ ﺗﺎﺑﻊ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻣﻲ ﺷﻮد:‬ ‫)‪DLLFile =Dir(“C:WINNT SYSTEM *.DLL”,FileAttribute.Hidden‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٤١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﺷﻤﺎ هﻤﭽﻨﻴﻦ ﻗﺎدر ﺑﻪ ﺗﺮآﻴﺐ ﭼﻨﺪﻳﻦ ﺻﻔﺖ ﺑﺎ هﻢ هـﺴﺘﻴﺪ. ﻣـﺜﻼ ﻓﺎﻳـﻞ هـﺎي ‪ DLL‬اي آـﻪ داراي‬ ‫ﺻﻔﺎت ﻣﺨﻔﻲ و ﻓﻘﻂ ﺧﻮاﻧﺪﻧﻲ و ﺳﻴﺴﺘﻤﻲ هﺴﺘﻨﺪ.‬ ‫ﺑــــﺮاي ﺗﻌﻴــــﻴﻦ ﻧــــﺎم زﻳﺮﭘﻮﺷــــﻪ هــــﺎﻳﻲ آــــﻪ در ﻳــــﻚ ﭘﻮﺷــــﻪ ﻗــــﺮار دارﻧــــﺪ ﺑﺎﻳــــﺪ از ﺻــــﻔﺖ‬ ‫‪ FileAttribute.Directory‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ آﻪ ﻧﺎم ﭘﻮﺷﻪ اﻳﻲ را ﺑﺮ ﮔﺸﺖ ﻣﻲ دهﺪ آﻪ ﻧﺮﻣـﺎل ﻳـﺎ‬ ‫اﺻﻄﻼﺣﺎ ﺑﺪون ﺻﻔﺖ ﺑﺎﺷﺪ. )در 0.6.‪ VB‬ﺑﺎ ﻧﺎم ‪ vbDirectory‬ﺷﻨﺎﺧﺘﻪ ﻣﻲ ﺷﻮد(‬ ‫ﺑﺮاي ﺗﻌﻴﻴﻦ اﻳﻨﻜﻪ ﻣﻘﺪار ورودي، ﻓﺎﻳﻞ اﺳﺖ ﻳﺎ ﭘﻮﺷﻪ ﺑﺎﻳـﺪ ﺧـﻮاص ﻣﻘـﺪار ورودي را ﺑـﺎ اﺳـﺘﻔﺎدﻩ از‬ ‫ﺗﺎﺑﻊ )(‪ GetAttr‬ﺑﺮرﺳﻲ آﻨﻴﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ ﺗﻌﺪاد زﻳﺮﭘﻮﺷﻪ هﺎي ﻣﻮﺟﻮد در ﭘﻮﺷﻪ ‪ System‬را ﺑﻪ دﺳﺖ ﻣﻲ ﺁورد:‬ ‫‪Dim path,FName As String‬‬ ‫‪Dim totFolders As Integer‬‬ ‫”‪path =“C:WindowsSystem‬‬ ‫)‪FName =Dir(path,FileAttribute.Directory‬‬ ‫”“>< ‪While FName‬‬ ‫_=)‪If (GetAttr(path &FName)And FileAttribute.Directory‬‬ ‫‪FileAttribute.Directory Then‬‬ ‫)‪Console.WriteLine(FName‬‬ ‫1 + ‪totFolders =totFolders‬‬ ‫‪End If‬‬ ‫)(‪FName =Dir‬‬ ‫‪End While‬‬ ‫)”‪Console.WriteLine(“Found“ & totFolders & “folders‬‬ ‫)‪FileCopy(source_file,dest_file‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻓﺎﻳﻞ را ﺑﻪ ﻳﻚ ﻣﻜﺎن ﺟﺪﻳﺪ ﺑﺮ روي هﺎرددﻳﺴﻚ آﭙﻲ ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،source_file‬ﻧﺎم ﻓﺎﻳﻠﻲ اﺳﺖ آﻪ ﻗﺮار اﺳﺖ آﭙﻲ ﺷﻮد.‬ ‫اﮔﺮ ﻓﺎﻳﻞ در ﭘﻮﺷﻪ ﺟﺎري ﺑﺎﺷﺪ ﻓﻘﻂ ذآﺮ ﻧﺎم ﻓﺎﻳﻞ آﻔﺎﻳـﺖ ﻣـﻲ آﻨـﺪ در ﻏﻴـﺮ اﻳﻨـﺼﻮرت ﺑﺎﻳـﺪ ﻣـﺴﻴﺮ‬ ‫آﺎﻣﻞ ﻓﺎﻳﻞ را ذآﺮ آﻨﻴﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ dest_file‬ﻧﺎم ﻓﺎﻳﻞ و ﻣﺴﻴﺮي اﺳﺖ آﻪ ﻓﺎﻳﻞ ﻗﺮار اﺳﺖ ﺑﻪ ﺁﻧﺠﺎ آﭙﻲ ﺷﻮد.‬ ‫ﺳﻪ ﻧﻜﺘﻪ ﻣﻬﻢ در راﺑﻄﻪ ﺑﺎ اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ:‬ ‫١( ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺮاي ﻓﺎﻳﻠﻲ آﻪ ﻗﺮار اﺳﺖ ﺑﻪ ﻣﻜﺎن دﻳﮕﺮي آﭙﻲ ﺷﻮد ﻧﺎم ﺟﺪﻳﺪي در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ.‬ ‫٢( در ﺻﻮرﺗﻲ آﻪ در ﻣﻮﻗﻊ آﭙﻲ ﻓﺎﻳﻞ، ﺑﺮﻧﺎﻣﻪ ي دﻳﮕﺮي در ﺣـﺎل اﺳـﺘﻔﺎدﻩ از ﻓﺎﻳـﻞ ﺑﺎﺷـﺪ، ﻓﺎﻳـﻞ‬ ‫آﭙﻲ ﻧﺨﻮاهﺪ ﺷﺪ.‬ ‫٣( در اﻳﻦ ﺗﺎﺑﻊ ﻣﺠﺎز ﺑﻪ اﺳﺘﻔﺎدﻩ از آﺎراآﺘﺮهﺎي ﺟﺎﻳﮕﺰﻳﻦ ﻧﻴﺴﺘﻴﺪ.)* و ؟( ﺑـﻪ ﻋﺒـﺎرت دﻳﮕـﺮ ﻧﻤـﻲ‬ ‫ﺗﻮاﻧﻴﺪ ﺗﻨﻬﺎ ﺑﺎ ﻳﻚ ﺑﺎر ﻓﺮاﺧﻮاﻧﻲ اﻳﻦ ﺗﺎﺑﻊ، ﭼﻨﺪﻳﻦ ﻓﺎﻳﻞ را هﻤﺰﻣﺎن آﭙﻲ آﻨﻴﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫”‪source =“C:VBExamplesFiles.txt‬‬ ‫”‪destination =“D:MasteringVBNewName.txt‬‬ ‫)‪FileCopy(source,destination‬‬ ‫اﻳﻦ دﺳـﺘﻮرات، ﻓﺎﻳـﻞ ‪ Files.txt‬را ﺑـﻪ ﻣﻜـﺎن ﺟﺪﻳـﺪي آﭙـﻲ آـﺮدﻩ و ﻧـﺎم ﻓﺎﻳـﻞ آﭙـﻲ ﺷـﺪﻩ را ﺑـﻪ‬ ‫‪ NewName.txt‬ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ.‬ ‫هﻤﭽﻨﻴﻦ ﻣﻲ ﺗﻮاﻧﻴﺪ هﻤﺎن ﻧﺎم ﻗﺒﻠﻲ ﻓﺎﻳﻞ را ﺑﻨﻮﻳﺴﻴﺪ.‬ ‫)‪Rename(oldpath,newpath‬‬ ‫ﺑﺎ آﻤﻚ اﻳﻦ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻧﺎم ﻳﻚ ﻓﺎﻳﻞ ﻳﺎ ﭘﻮﺷﻪ را ﺗﻐﻴﻴﺮ دهﻴﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،oldpath‬ﻧﺎم و ﻣﺴﻴﺮ ﻓﺎﻳﻞ ﻳﺎ ﭘﻮﺷﻪ اي را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ ﻗﺮار اﺳﺖ ﺗﻐﻴﻴﺮ ﻧـﺎم ﭘﻴـﺪا‬ ‫آﻨﺪ و ﻧﺎم ﺟﺪﻳﺪ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺁرﮔﻮﻣﺎن ‪ newpath‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)”‪Rename(“C:Users”,“C:All Users‬‬ ‫اﻳﻦ دﺳﺘﻮر، ﭘﻮﺷﻪ ‪ Users‬را در دراﻳﻮ ‪ C‬ﺑﻪ ‪ All Users‬ﺗﻐﻴﻴﺮ ﻧﺎم ﻣﻲ دهﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٥١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﻧﻜﺎت ﻣﻬﻢ در اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ:‬ ‫ﺗﻐﻴﻴﺮ ﻧﺎم ﭘﻮﺷﻪ، ﺗﺎﺛﻴﺮي در ﺷﺎﻣﻞ ﺑﻮدن زﻳﺮﭘﻮﺷﻪ هﺎ و ﻓﺎﻳﻞ هﺎ در ﺁن ﻧﺪارد.‬ ‫اﮔﺮ ﺷﻤﺎ ﻗﺼﺪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ دو ﭘﻮﺷﻪ ﺗﻮ در ﺗﻮ را هﻤﺰﻣﺎن ﺗﻐﻴﻴﺮ ﻧﺎم دهﻴﺪ ﻳﻚ ﺧﻄـﺎ رخ ﺧﻮاهـﺪ‬ ‫داد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل:‬ ‫)”1‪Rename(“C:Users New User”, “C:All Users User‬‬ ‫ﺑﺎ اﺟﺮاي اﻳﻦ دﺳﺘﻮر، ﻳﻚ ﺧﻄﺎ اﺗﻔﺎق ﺧﻮاهﺪ اﻓﺘﺎد.‬ ‫ﺑﺮاي ﺗﻐﻴﻴﺮ ﻧﺎم دو ﻳﺎ ﭼﻨﺪ ﭘﻮﺷﻪ ي ﺗﻮ در ﺗﻮ ﺑﺎﻳﺪ ﺁﻧﻬﺎ را ﻳﻜﻲ ﻳﻜﻲ ﺗﻐﻴﻴﺮ ﻧﺎم دهﻴﺪ.‬ ‫ﺗﺎﺑﻊ ‪ Rename‬هﻤﭽﻨﻴﻦ در ﺻﻮرت ﻧﻴﺎز، در هﻨﮕﺎم ﺗﻐﻴﻴﺮ ﻧﺎم ﻳﻚ ﻓﺎﻳﻞ ﻗﺎدر ﺑﻪ اﻧﺘﻘﺎل ﺁن )‪ (Cut‬ﺑﻪ‬ ‫ﻳﻚ ﻣﻜﺎن ﺟﺪﻳﺪ ﺑﺮ روي هﺎرددﻳﺴﻚ اﺳﺖ.‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ اﻳﻦ ﺗﺎﺑﻊ ﻗﺎدر ﺑﻪ اﻧﺘﻘﺎل ﭘﻮﺷﻪ هﺎ ﻧﻴﺴﺖ.‬ ‫ﺑﻪ ﻋﻨﻮام ﻣﺜﺎل ﻓﺮﻣﺎن زﻳﺮ ﻓﺎﻳﻞ ‪ Profile1.cps‬را در ﻣﺴﻴﺮ ﻣﺸﺨﺺ ﺷﺪﻩ در دراﻳﻮ ‪ C‬هﻤﺮاﻩ ﺑﺎ‬ ‫ﺗﻐﻴﻴﺮ ﻧﺎم ﺁن ﺑﻪ ‪ UserProfile.cps‬ﺑﻪ ﻣﺴﻴﺮ ﻣﺸﺨﺺ ﺷﺪﻩ در دراﻳﻮ ‪ D‬ﻣﻨﺘﻘﻞ ﻣﻲ آﻨﺪ:‬ ‫)”‪Rename(“C:AllUsersUser1Profile1.cps”, “D:New UserUserProfile.cps‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻗﺎدر ﺑﻪ اﻳﺠﺎد ﻳﻚ ﭘﻮﺷﻪ ي ﺟﺪﻳﺪ ﻧﻴﺴﺖ.‬ ‫ﺗﺎﺑﻊ ‪ Reaname‬ﺑﺮ روي ﻓﺎﻳﻞ هﺎي ﺑﺎز ﻳﺎ ﻓﺎﻳﻞ هﺎﻳﻲ آـﻪ ﺗﻮﺳـﻂ ﺑﺮﻧﺎﻣـﻪ هـﺎي دﻳﮕـﺮ، هﻤﺰﻣـﺎن در‬ ‫ﺣﺎل اﺳﺘﻔﺎدﻩ هﺴﺘﻨﺪ آﺎرﺑﺮد ﻧﺪارد.‬ ‫در اﻳﻦ ﺗﺎﺑﻊ ﻣﺠﺎز ﺑﻪ اﺳﺘﻔﺎدﻩ از آﺎراآﺘﺮهﺎي ﺟﺎﻳﮕﺰﻳﻦ)* و ؟( ﻧﻴﺴﺘﻴﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٦١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)‪:(Data Type Identification‬‬ ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺮاي ﺷﻨﺎﺳﺎﻳﻲ ﻧﻮع دادﻩ هﺎ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‬ ‫ﺗﻮاﺑﻊ ﻣﻮﺟﻮد در اﻳﻦ ﺑﺨﺶ، ﺗﻨﻬﺎ ﻧﻮع دادﻩ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﻨﺪ.‬ ‫)‪IsArray(variable‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ ﻳﻚ ﻣﺘﻐﻴﺮ از ﻧﻮع ﺁراﻳﻪ اﺳﺖ ﻳﺎ ﺧﻴﺮ. ﭼﻨﺎﻧﭽـﻪ از ﻧـﻮع ﺁراﻳـﻪ ﺑﺎﺷـﺪ، ﺗـﺎﺑﻊ‬ ‫ﻣﻘﺪار ‪ True‬و ﮔﺮﻧﻪ ‪ False‬را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ variable‬ﻧﺎم ﻣﺘﻐﻴﺮي اﺳﺖ آﻪ ﺑﺎﻳﺪ ﺑﺮرﺳﻲ ﺷﻮد.‬ ‫ﻣﺜﺎل هﺎي زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)001(‪Dim names‬‬ ‫)‪IsArray(names‬‬ ‫ﺧﺮوﺟﻲ اﻳﻦ ﺗﺎﺑﻊ ‪ True‬اﺳﺖ ﭼﻮن آﻪ ‪ names‬ﺑﻪ ﻋﻨﻮان ﻳﻚ ﺁراﻳﻪ ٠٠١ ﺗﺎﻳﻲ ﺗﻌﺮﻳﻒ ﺷﺪﻩ اﺳﺖ.‬ ‫‪Dim A As Integer‬‬ ‫)‪IsArray(A‬‬ ‫ﺧﺮوﺟﻲ ﺗﺎﺑﻊ در اﻳﻦ ﺣﺎﻟﺖ، ‪ False‬اﺳﺖ زﻳﺮا ‪ A‬ﻣﺘﻐﻴﺮي از ﻧﻮع ﺻﺤﻴﺢ ﺗﻌﺮﻳﻒ ﺷﺪﻩ اﺳﺖ.‬ ‫)‪IsDate(expression‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ اﺳﺖ ﻳﺎ ﺧﻴﺮ. ﭼﻨﺎﻧﭽﻪ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ ﺑﺎﺷﺪ،‬ ‫ﺗﺎﺑﻊ ‪ True‬و ﮔﺮﻧﻪ ‪ False‬را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ expression‬ﻋﺒﺎرﺗﻲ اﺳﺖ آﻪ ﺑﺎﻳﺪ ﭼﻚ ﺷﻮد.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)”‪BDate =InputBox(“Please enter your birth date‬‬ ‫‪If IsDate(BDate)Then‬‬ ‫”‪MsgBox “Date accepted‬‬ ‫‪End If‬‬ ‫)‪IsDBNull(expression‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ در ﺻﻮرﺗﻲ آﻪ ﻳﻚ ﻣﻘﺪار، ‪ DBNull‬ﺑﺎﺷﺪ، ﻣﻘﺪار ‪ True‬را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫‪ DBValue‬ﻣﻘﺪاري اﺳﺖ آﻪ وﺟﻮد ﻧﺪارد و ﺑﺎ ﻣﻘﺪار ‪ Nothing‬ﺗﻔﺎوت دارد.‬ ‫‪ DBValue‬ﻧﻤﺎﻳﺎﻧﮕﺮ ﺁن اﺳﺖ آﻪ از ذآﺮ ﻳﻚ ﻣﻘﺪار ﺧﻮدداري ﺷﺪﻩ و ﻳﺎ ﻧﻮع ﺁن ﺗﻌﺮﻳﻒ ﻧﺸﺪﻩ.‬ ‫)‪IsNothing(expression‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ ﺁﻳﺎ ﻣﻘﺪاري )ﻣﺘﻐﻴﺮي( آﻪ از ﻧﻮع ‪) Object‬ﺷـﻲ( ﺗﻌﺮﻳـﻒ ﺷـﺪﻩ داراي‬ ‫ﻣﻘﺪار اﺳﺖ ﻳﺎ ﺧﻴﺮ. اﮔـﺮ ﻣﻘـﺪاراي ﺑـﻪ ﺁن ﻧـﺴﺒﺖ دادﻩ ﺷـﺪﻩ ﺑﺎﺷـﺪ، ﺧﺮوﺟـﻲ ﺗـﺎﺑﻊ ‪ True‬و ﮔﺮﻧـﻪ‬ ‫‪ False‬اﺳﺖ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫‪Dim obj As Object‬‬ ‫ﺑﻌﺪ از اﻳﻦ ﺗﻌﺮﻳﻒ، ﺧﺮوﺟﻲ ﻋﺒﺎرت )‪ IsNothing(obj‬ﺑﺮاﺑﺮ ‪ True‬اﺳـﺖ ﭼـﻮن هﻨـﻮز ﻣﻘـﺪاري ﺑـﻪ‬ ‫ﻣﺘﻐﻴﺮ ﻣﺎ ﻧﺴﺒﺖ دادﻩ ﻧﺸﺪﻩ اﺳﺖ.‬ ‫ﺣﺎﻻ ﻣﺎ ﻳﻚ ﻣﻘﺪار از ﻧﻮع ‪) Object‬ﺷﻲ( را ﺑﻪ اﻳﻦ ﻣﺘﻐﻴﺮ ﻧﺴﺒﺖ ﻣﻲ دهﻴﻢ:‬ ‫)21,21,001,01(‪obj =New Rectangle‬‬ ‫ﺑﻌﺪ از اﺟﺮاي اﻳﻦ دﺳﺘﻮر، ﻣﺘﻐﻴﺮ ﻣﺎ داراي ﻣﻘﺪار اﺳﺖ و ﺧﺮوﺟﻲ ﻋﺒـﺎرت )‪ IsNothing(obj‬ﺑﺮاﺑـﺮ‬ ‫‪ False‬ﻣﻲ ﺑﺎﺷﺪ.‬ ‫در اﻳﻦ ﻣﺜﺎل ﻣﻲ ﺗﻮان ﺑﺎ ﻧﻮﺷﺘﻦ ﻓﺮﻣﺎن ‪ ،Set obj=Nothing‬ﻓﻀﺎي اﺷﻐﺎل ﺷـﺪﻩ ﺣﺎﻓﻈـﻪ را آـﻪ‬ ‫ﺑﺮاي اﻳﺠﺎد اﻳﻦ ﺷﻲ در اﺧﺘﻴﺎر ﺑﺮﻧﺎﻣﻪ ﻗﺮار ﮔﺮﻓﺘﻪ اﺳﺖ ﺑﻪ ﺣﺎﻓﻈﻪ اﺻﻠﻲ ﺑﺮﮔﺮداﻧﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٧١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﺑﻪ دو ﺷﻜﻞ ﻣﻲ ﺗﻮان اﻳﻦ ﺗﺎﺑﻊ را ﺑﻪ آﺎر ﺑﺮد:‬ ‫١( ‪If IsNothing(obj) Then‬‬ ‫٢( ‪If obj Is Nothing Then‬‬ ‫در ﺷﻜﻞ دوم، از آﻠﻤﻪ ي آﻠﻴﺪي )‪ (Is‬اﺳﺘﻔﺎدﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫)‪IsNumeric(expression‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ رﺷﺘﻪ را ﺗﺴﺖ ﻣﻲ آﻨﺪ و ﭼﻨﺎﻧﭽﻪ آﻠﻴﻪ آﺎراآﺘﺮهﺎي رﺷﺘﻪ، ارﻗﺎم ﺑﻴﻦ 0 ﺗﺎ 9 ﺑﺎﺷـﻨﺪ،‬ ‫ﻣﻘﺪار ‪ True‬و ﮔﺮﻧﻪ ﻣﻘﺪار ‪ False‬را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)”‪age =InputBox(“Please enter your age‬‬ ‫‪If Not IsNumeric(age)Then‬‬ ‫)”‪MsgBox(“Please try again,this time with a valid number‬‬ ‫‪End If‬‬ ‫در اﻳﻦ ﻣﺜﺎل ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ ،InputBox‬ﺳﻦ آﺎرﺑﺮ درﺧﻮاﺳﺖ ﻣـﻲ ﺷـﻮد و ﺳـﭙﺲ ﻣﻘـﺪار‬ ‫ورودي آﺎرﺑﺮ ﺑﺎ ﺗﺎﺑﻊ )(‪ IsNumeric‬ﭼﻚ ﻣﻲ ﺷـﻮد. ﭼﻨﺎﻧﭽـﻪ آـﺎرﺑﺮ آـﺎراآﺘﺮي ﻏﻴـﺮ ﻋـﺪدي را وارد‬ ‫آﺮدﻩ ﺑﻮد، ﺑﻪ او اﻃﻼع دادﻩ ﻣﻲ ﺷﻮد.‬ ‫)‪IsReference(expression‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آـﻪ ﻳـﻚ ﻣﺘﻐﻴـﺮ از ﻧـﻮع ‪ Object‬ﻳـﺎ ‪ Reference‬اﺿـﺎﻓﻪ ﺷـﺪﻩ ﺑـﻪ ﺑﺮﻧﺎﻣـﻪ‬ ‫اﺳﺖ ﻳﺎ ﺧﻴﺮ و ﺧﺮوﺟﻲ ﺁن ﻳﺎ ‪ True‬و ﻳﺎ ‪ False‬اﺳﺖ.‬ ‫)‪TypeName(variable_name‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻧﻮع ﻳﻚ ﻣﺘﻐﻴﺮ را ﺑﻪ ﺻﻮرت رﺷﺘﻪ اي ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻣﻤﻜﻦ اﺳﺖ ﻣﺘﻐﻴﺮي آﻪ ﺷﻤﺎ ﻣﻲ ﺧﻮاهﻴﺪ ﻧﻮع ﺁن را ﺑﺎ اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ دﺳﺖ ﺁورﻳﺪ، ﺗﻌﺮﻳـﻒ ﺷـﺪﻩ ﻳـﺎ‬ ‫ﻧﺸﺪﻩ ﺑﺎﺷﺪ.‬ ‫ﻓﺮض ﻣﻲ آﻨﻴﻢ آﻪ ﻣﺘﻐﻴﺮهﺎي زﻳﺮ ﺗﻌﺮﻳﻒ ﺷﺪﻩ اﻧﺪ:‬ ‫‪Dim name As Integer‬‬ ‫‪Dim a‬‬ ‫دﺳﺘﻮرات زﻳﺮ ﻧﺘﺎﻳﺞ زﻳﺮ را ﺗﻮﻟﻴﺪ ﻣﻲ آﻨﻨﺪ:‬ ‫))‪Console.WriteLine(TypeName(name‬‬ ‫‪Integer‬‬ ‫))‪Console.WriteLine(TypeName(a‬‬ ‫‪Nothing‬‬ ‫”‪a =“I ’m a string‬‬ ‫))‪Console.WriteLine(TypeName(a‬‬ ‫‪String‬‬ ‫)‪VarType(variable‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻧﻮع ﻳﻚ ﻣﺘﻐﻴﺮ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ هﻤﺎﻧﻨﺪ ﺗﺎﺑﻊ )(‪ TypeName‬ﻋﻤﻞ ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ اﻳﻦ ﺗﺎﺑﻊ، ﻳـﻚ ﻣﻘـﺪار ﻋـﺪدي‬ ‫را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ وﻟﻲ ﺗﺎﺑﻊ ‪ TypeName‬ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي را ﺑﺮﮔﺸﺖ ﺧﻮاهﺪ داد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،Variable‬ﻣﺘﻐﻴﺮي اﺳﺖ آﻪ ﻧﻮع ﺁن ﺑﺎﻳﺪ ﻣﺸﺨﺺ ﺷﻮد.‬ ‫ﻣﻘﺎدﻳﺮي آﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ در زﻳﺮ ﻟﻴﺴﺖ ﺷﺪﻩ اﺳﺖ:‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٨١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‬VarType() ‫ﻣﻘﺎدﻳﺮي آﻪ ﺗﺎﺑﻊ‬ ‫ﻣﻘﺪار‬ Array Boolean Byte Char Currency DataObject Date Decimal Double Empty Error Integer Long Null Object Short Single String UserDefinedType Variant .‫ ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﺪ ﺷﺪ‬VarType() ‫ﻣﻘﺪار ﺛﺎﺑﺖ ﻋﺪدي اﻳﻦ ﻣﻘﺎدﻳﺮ ﺗﻮﺳﻂ ﺗﺎﺑﻊ‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ١٩ Visual Basic.NET ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ‬
‫)‪:(Variable Type Conversion‬‬ ‫ﺗﻮاﺑﻊ ﺗﺒﺪﻳﻞ ﻧﻮع ﻣﺘﻐﻴﺮ‬ ‫ﻣﺘﻐﻴﺮهﺎ ﻗﺎﺑﻠﻴﺖ ﺗﺒﺪﻳﻞ ﺷﺪن ﺑﻪ ﻳﻜﺪﻳﮕﺮ را دارﻧﺪ.‬ ‫ﺗﻤﺎﻣﻲ ﺗﻮاﺑﻊ اﻳﻦ ﺑﺨﺶ ﺁرﮔﻮﻣﺎن هﺎي ﻋﺪدي ﻣﻲ ﭘﺬﻳﺮﻧﺪ و ﺁﻧﻬﺎ را ﺗﺒﺪﻳﻞ ﺑﻪ ﻧﻮع دﻳﮕﺮي از ﻣﺘﻐﻴﺮهـﺎ‬ ‫ﻣﻲ آﻨﻨﺪ.‬ ‫اﻳﻦ ﺗﻮاﺑﻊ را در ﺟﺪول زﻳﺮ ﻣﺸﺎهﺪﻩ ﻣﻲ آﻨﻴﺪ:‬ ‫ﺗﻮاﺑﻊ ﺗﺒﺪﻳﻞ ﻧﻮع ﻣﺘﻐﻴﺮ‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻧﺎم ﺗﺎﺑﻊ‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Boolean‬‬ ‫) ‪CBool(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Byte‬‬ ‫) ‪CByte(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Char‬‬ ‫) ‪CChar(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Date‬‬ ‫) ‪CDate(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Decimal‬‬ ‫) ‪CDec(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Double‬‬ ‫) ‪CDbl(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Integer‬‬ ‫) ‪CInt(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Long‬‬ ‫) ‪CLng(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Object‬‬ ‫) ‪CObj(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Short‬‬ ‫) ‪Cshort(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Single‬‬ ‫) ‪CSng(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪String‬‬ ‫) ‪CStr(expression‬‬ ‫ﻧﻮع ﺳﻔﺎرﺷﻲ‬ ‫) ‪CType(expression,type‬‬ ‫)‪CType(varName,typeName‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻣﻘﺪار ﻳﺎ ﻋﺒﺎرت را آﻪ ﻣﻘﺪار ﺁن در ﺁرﮔﻮﻣﺎن ‪ varName‬ﺗﻌﻴﻴﻦ ﺷﺪﻩ ﺑﻪ ﻧـﻮﻋﻲ آـﻪ در‬ ‫ﺁرﮔﻮﻣﺎن ‪ typeName‬ﻣﺸﺨﺺ ﺷﺪﻩ ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ.‬ ‫دﺳﺘﻮرات زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)‪CType(1000, System.Double‬‬ ‫)‪CType(“1000”, System.Double‬‬ ‫اوﻟﻴﻦ دﺳﺘﻮر، ﻣﻘﺪار ٠٠٠١ را آﻪ از ﻧﻮع ﻋﺪد ﺻﺤﻴﺢ )‪ (Integer‬اﺳﺖ و دﺳﺘﻮر دوم ﻣﻘﺪار ٠٠٠١‬ ‫را آﻪ از ﻧﻮع رﺷﺘﻪ اي )‪ (String‬اﺳﺖ ﺑﻪ ﻧﻮع ﻋﺪد اﻋﺸﺎري ﺑﺎ دﻗﺖ ﻣﻀﺎﻋﻒ )‪ (Double‬ﺗﺒـﺪﻳﻞ‬ ‫ﻣﻲ آﻨﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٠٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)‪:(String Manipulation‬‬ ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ رﺷﺘﻪ هﺎ ﺳﺮ و آﺎر دارﻧﺪ‬ ‫در ‪ VB.NET‬ﺗﻮاﺑﻊ ﺑﺴﻴﺎر ﻣﻬﻢ، ﻣﻔﻴﺪ و آﺎرﺁﻣﺪي ﺟﻬﺖ آﺎر ﺑﺎ رﺷﺘﻪ هﺎ وﺟﻮد دارﻧﺪ.‬ ‫ﻣﻴﺎﻧﮕﻴﻨﻲ آﻪ در راﺑﻄﻪ ﺑﺎ ﻋﻤﻠﻜﺮد ﺑﺮﻧﺎﻣﻪ هﺎي آﺎرﺑﺮدي ﮔﺮﻓﺘـﻪ ﺷـﺪﻩ ﻧـﺸﺎن ﻣـﻲ دهـﺪ آـﻪ ﺗﻮاﺑـﻊ‬ ‫رﺷﺘﻪ اي ﺑﻴﺶ از ﺗﻮاﺑﻊ ﻋﺪدي آﺎرﺑﺮد دارﻧﺪ.‬ ‫در اﻳﻦ ﺑﺨﺶ دو ﺗﺎﺑﻊ هﻤﻨﺎم ﺑﻪ ﻧﺎم هﺎي )(‪ Mid‬و ‪ Mid‬وﺟﻮد دارد آـﻪ ﻋﻤﻠﻜـﺮدي ﺷـﺒﻴﻪ ﺑـﻪ هـﻢ‬ ‫داﺷﺘﻪ و در ﺟﺎي ﺧﻮد ﺑﺤﺚ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫ﺗﻤـــــﺎﻣﻲ ﺗﻮاﺑـــــﻊ رﺷـــــﺘﻪ اي ‪ VB.NET‬داراي ﻣﺘــــ ـﺪ و ﺧـــــﻮاص ﻣـــــﺸﺎﺑﻪ و ﺑﺮاﺑــــ ـﺮ ي در‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫آﻼس ‪ System.String‬هﻤﺎﻧﻨﺪ آﻼس ‪ StringBuilder‬هﺴﺘﻨﺪ.‬ ‫)‪Asc(character) , AscW(string‬‬ ‫ﺗﺎﺑﻊ )(‪ ،Asc‬آﺪ اﺳﻜﻲ ﻳﻚ آﺎراآﺘﺮ را آﻪ ﻧـﺎم در ﺁرﮔﻮﻣـﺎن ‪ character‬ذآـﺮ ﺷـﺪﻩ، ﺑﺮﮔـﺸﺖ ﻣـﻲ‬ ‫دهﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺑﺮ روي هﻤﻪ ﺳﻴﺴﺘﻢ هﺎ آﺎر ﻣﻲ آﻨـﺪ ﺣﺘـﻲ اﮔـﺮ ﺁن ﺳﻴـﺴﺘﻢ از ‪ Unicode‬ﭘـﺸﺘﻴﺒﺎﻧﻲ‬ ‫ﻧﻜﻨﺪ.‬ ‫اﮔﺮ در ﺁرﮔﻮﻣﺎن ‪ character‬ﺑﻪ ﺟﺎي آﺎراآﺘﺮ، ﻳﻚ آﻠﻤﻪ ﻳﺎ رﺷﺘﻪ ﺁوردﻩ ﺷﻮد، اوﻟﻴﻦ آـﺎراآﺘﺮ رﺷـﺘﻪ‬ ‫در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫ﺗﺎﺑﻊ )(‪ AscW‬ﻋﻤﻠﻜﺮدي ﺷﺒﻴﻪ ﺑﻪ ﺗﺎﺑﻊ )(‪ Asc‬دارد ﺑﺎ اﻳـﻦ ﺗﻔـﺎوت آـﻪ آـﺪ اﺳـﻜﻲ آـﺎراآﺘﺮ را ﺑـﻪ‬ ‫ﺻﻮرت ‪ Unicode‬ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ در ﺻـﻮرﺗﻲ آـﻪ ﺗـﺎﺑﻊ )(‪ Asc‬آـﺪ اﺳـﻜﻲ را ﺑـﻪ ﺻـﻮرت ﺑﺎﻳـﺖ‬ ‫ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫از اﻳﻦ ﺗﻮاﺑﻊ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺟﻬﺖ ﺗﺒﺪﻳﻞ آﺎراآﺘﺮ آﻠﻴﺪ ﻓﺸﺮدﻩ ﺷﺪﻩ ﺗﻮﺳﻂ آﺎرﺑﺮ ﺑﻪ آﺪ اﺳـﻜﻲ ﻣﻌـﺎدل‬ ‫ﺁن اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﺑـﻪ ﻋﻨـﻮان ﻣﺜـﺎل ﻧﺘﻴﺠـﻪ ﺧﺮوﺟـﻲ )”‪ ،ASC(“Ali‬ﻋـﺪد 56 اﺳـﺖ و ﻧﺘﻴﺠـﻪ ﺧﺮوﺟـﻲ )”‪،ASC(“N‬‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ﻋﺪد 87 اﺳﺖ.‬ ‫)‪Chr(number) , ChrW(number‬‬ ‫اﻳﻦ دو ﺗﺎﺑﻊ دﻗﻴﻘﺎ ﻋﻜﺲ ﺗﻮاﺑﻊ )(‪ Asc‬و )(‪ AscW‬ﻋﻤﻞ ﻣﻲ آﻨﻨﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ ،Chr‬آﺎراآﺘﺮ ﻣﻌﺎدل آﺪ اﺳﻜﻲ ﻳﻚ ﻋﺪد از ﻧﻮع ﺑﺎﻳﺖ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫از اﻳﻦ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺟﻬﺖ ﭼﺎپ ﺣﺮوف ﻳـﺎ آﺎراآﺘﺮهـﺎﻳﻲ آـﻪ ﺑـﺮ روي ﺻـﻔﺤﻪ آﻠﻴـﺪ وﺟـﻮد ﻧﺪارﻧـﺪ‬ ‫هﻤﺎﻧﻨﺪ ﺷﻜﻠﻚ هﺎ ﻳﺎ ﺣﺮوﻓﻲ آﻪ آﺪ اﺳﻜﻲ ﺁﻧﻬﺎ از 721 ﺑﻴﺸﺘﺮ اﺳﺖ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ ChrW‬ﻧﻴﺰ ﻳﻚ آﺎراآﺘﺮ از ﻧﻮع ‪ Unicode‬ﻳﻚ ﻣﻘﺪار ﻋﺪدي را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫از اﻳﻦ ﺗﻮاﺑﻊ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺟﻬﺖ ﺗﺒﺪﻳﻞ آﺪ اﺳﻜﻲ آﻠﻴﺪ ﻓﺸﺮدﻩ ﺷﺪﻩ ﺗﻮﺳﻂ آﺎرﺑﺮ ﺑﻪ آـﺎراآﺘﺮ ﻣﻌـﺎدل‬ ‫ﺁن اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫)‪LCase(string) , UCase(string‬‬ ‫ﺗﺎﺑﻊ )(‪ ،Lcase‬در ﻳﻚ رﺷﺘﻪ، ﺣﺮوف ﺑﺰرگ رﺷﺘﻪ را ﺑﻪ ﺣﺮوف آﻮﭼﻚ ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ ،Ucase‬در ﻳﻚ رﺷﺘﻪ، ﺣﺮوف آﻮﭼﻚ رﺷﺘﻪ را ﺑﻪ ﺣﺮوف ﺑﺰرگ ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫”‪Title =“Visual Basic.Net‬‬ ‫)‪LTitle =LCase(Title‬‬ ‫)‪UTitle =UCase(Title‬‬ ‫ﺑﻌﺪ از اﺟﺮاي اﻳﻦ دﺳﺘﻮرات ﻣﺘﻐﻴﺮهﺎي ‪ Ltitle‬و ‪ ،Utitle‬داراي ﻣﻘﺎدﻳﺮ زﻳﺮ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫"‪Ltitle=”visual basic.net‬‬ ‫”‪Utitle=”VISUAL BASIC.NET‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫١٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)] ‪InStr([startPos,] string1,string2 [,compare‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، زﻳﺮرﺷﺘﻪ اي را در رﺷﺘﻪ دﻳﮕﺮ ﺟﺴﺘﺠﻮ آﺮدﻩ و ﻣﺤﻞ وﺟـﻮد زﻳﺮرﺷـﺘﻪ در رﺷـﺘﻪ را ﺑﺮﻣـﻲ‬ ‫ﮔﺮداﻧﺪ.‬ ‫اوﻟﻴﻦ ﺁرﮔﻮﻣﺎن، اﺧﺘﻴﺎري اﺳﺖ و ﻣﻜﺎﻧﻲ از رﺷﺘﻪ اﺳﺖ آﻪ ﺟـﺴﺘﺠﻮ ﺑﺎﻳـﺪ از ﺁﻧﺠـﺎ ﺁﻏـﺎز ﺷـﻮد. اﮔـﺮ‬ ‫ذآﺮ ﻧﺸﻮد 1 در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد و ﺟﺴﺘﺠﻮ از اﺑﺘﺪاي رﺷﺘﻪ ﺁﻏﺎز ﺧﻮاهﺪ ﺷﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺁرﮔﻮﻣﺎن 2‪ string‬را در ﺁرﮔﻮﻣﺎن 1‪ string‬ﺟﺴﺘﺠﻮ ﻣﻲ آﻨﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫”‪str1 =“The quick brown fox jumped over the lazy dog‬‬ ‫”‪str2 =“the‬‬ ‫)2‪Pos =Instr(str1, str‬‬ ‫ﺑﻌﺪ از اﺟﺮاي دﺳﺘﻮرات ﻓﻮق، ﻣﺘﻐﻴﺮ ‪ Pos‬داراي ﻣﻘﺪار 33 ﺧﻮاهﺪ ﺷﺪ.‬ ‫ﻧﻜﺎت ﻣﻬﻢ:‬ ‫١( اﮔﺮ رﺷﺘﻪ اي آﻪ ﺟﺴﺘﺠﻮ ﺑﺮاي ﺁن ﺁﻏﺎز ﻣﻲ ﺷﻮد ﺑﻴﺶ از ﻳـﻚ ﺑـﺎر در رﺷـﺘﻪ ﺟـﺴﺘﺠﻮ ﺷـﻮﻧﺪﻩ‬ ‫ﺗﻜﺮار ﺷﺪﻩ ﺑﺎﺷﺪ و آﻠﻤﻪ ﺑﺎﺷﺪ، ﻣﺤﻞ ﺁﺧﺮﻳﻦ وﺟﻮد ﺁن ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد هﻤﺎن ﻃﻮر آﻪ در‬ ‫اﻳﻦ ﻣﺜﺎل آﻠﻤﻪ ‪ ،the‬دوﺑﺎر ﺗﻜﺮار ﺷﺪﻩ اﺳﺖ اﻣﺎ اﮔﺮ ﻗـﺴﻤﺘﻲ از ﻳـﻚ آﻠﻤـﻪ ﺑﺎﺷـﺪ، ﺣﺘـﻲ اﮔـﺮ‬ ‫ﭼﻨﺪﻳﻦ ﺑﺎر هﻢ ﺗﻜﺮار ﺷﺪﻩ ﺑﺎﺷﺪ، ﻣﺤﻞ اوﻟﻴﻦ وﻗﻮع ﺁن ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﺪ ﺷﺪ.‬ ‫٢(ﺟﺴﺘﺠﻮ ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ آﻮﭼﻚ ﻳﺎ ﺑﺰرگ ﺑـﻮدن ﺣـﺮوف اﻧﺠـﺎم ﺧﻮاهـﺪ ﺷـﺪ ﻳﻌﻨـﻲ‬ ‫ﻓﺮﺿﺎ آﻠﻤﺎت ‪ The ،the‬و ‪ THE‬ﺑﺎ هﻢ ﺗﻔﺎوت دارﻧﺪ.‬ ‫و اﻳﻦ ﺗﻨﻈﻴﻢ ﺑﻪ وﺳﻴﻠﻪ ﺗﻐﻴﻴﺮ ﺁﺧـﺮﻳﻦ ﺁرﮔﻮﻣـﺎن ﻳﻌﻨـﻲ ‪ compare‬آـﻪ ﺑـﻪ ﻃـﻮر ﭘـﻴﺶ ﻓـﺮض ﻣﻘـﺪار‬ ‫‪ CompareMethod.Binary‬را دارد ﻣﻲ ﺗﻮاﻧﺪ ﺗﻐﻴﻴﺮ آﻨﺪ.‬ ‫ﺑـــﺮاي اﻳﻨﻜـــﻪ ﺑـــﺰرگ ﻳـــﺎ آﻮﭼـــﻚ ﺑـــﻮدن ﺣـــﺮوف، در ﺟـــﺴﺘﺠﻮ ﻧﺎدﻳـــﺪﻩ ﮔﺮﻓﺘـــﻪ ﺷـــﻮد، ﻣﻘـــﺪار‬ ‫ﺁرﮔﻮﻣﺎن ‪ Compare‬را ﺑﻪ ‪ CompareMethod.Text‬ﺗﻐﻴﻴﺮ دهﻴﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫”‪str1 =“The quick brown fox jumped over the lazy dog‬‬ ‫”‪str2 =“the‬‬ ‫)‪Pos =InStr(1, str1, str2, CompareMethod.Text‬‬ ‫ﭘــﺲ از اﺟــﺮاي اﻳــﻦ دﺳــﺘﻮرات ﻣﻘــﺪار ﻣﺘﻐﻴــﺮ ‪ 1 ،pos‬ﺧﻮاهــﺪ ﺷــﺪ. در ﺻــﻮرﺗﻲ آــﻪ ﺁرﮔﻮﻣــﺎن‬ ‫‪ compare‬را ﺑﻪ ‪ CompareMethod.Binary‬ﺗﻐﻴﻴﺮ دهﻴﻢ ﻣﻘﺪار ﻣﺘﻐﻴﺮ ‪ 33 ،pos‬ﺧﻮاهﺪ ﺷﺪ.‬ ‫)] ‪InStrRev(string1,string2 [,start ][,compare‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ هﻤﺎﻧﻨـﺪ ﺗـﺎﺑﻊ )(‪ InStr‬ﻋﻤـﻞ ﻣـﻲ آﻨـﺪ ﺑـﺎ اﻳـﻦ ﺗﻔـﺎوت آـﻪ در ﺗـﺎﺑﻊ )(‪ InStr‬ﺟـﺴﺘﺠﻮ از‬ ‫اﺑﺘﺪاي رﺷﺘﻪ )ﭼﭗ ﺑﻪ راﺳـﺖ( وﻟـﻲ در ﺗـﺎﺑﻊ ‪ InStrRev‬ﺟـﺴﺘﺠﻮ از اﻧﺘﻬـﺎي رﺷـﺘﻪ )راﺳـﺖ ﺑـﻪ‬ ‫ﭼﭗ( اﻧﺠﺎم ﻣﻲ ﺷﻮد.‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﺟﺎي ﺁرﮔﻮﻣﺎن ‪ start‬در اﻳﻦ ﺗﺎﺑﻊ ﻋﻮض ﺷﺪﻩ.‬ ‫)] ‪StrComp(string1,string2 [,compare‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، دو رﺷﺘﻪ را ﺑﺎ ﻳﻜﺪﻳﮕﺮ ﻣﻘﺎﻳﺴﻪ آﺮدﻩ و ﺣﺎﺻﻞ ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن هﺎي 1‪ string‬و 2‪ string‬رﺷﺘﻪ هـﺎﻳﻲ هـﺴﺘﻨﺪ آـﻪ ﺑﺎﻳـﺪ ﺑـﺎ ﻳﻜـﺪﻳﮕﺮ ﻣﻘﺎﻳـﺴﻪ ﺷـﻮﻧﺪ و‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،compare‬روش ﻣﻘﺎﻳﺴﻪ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ.‬ ‫اﮔﺮ دو رﺷﺘﻪ ﺑﺎ هﻢ ﺑﺮاﺑﺮ ﺑﺎﺷﻨﺪ، ﺗﺎﺑﻊ ﻣﻘﺪار 0 را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫اﮔﺮ رﺷﺘﻪ اول ﺑﺰرﮔﺘﺮ از رﺷﺘﻪ دوم ﺑﺎﺷﺪ، ﺗﺎﺑﻊ ﻣﻘﺪار 1 را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫اﮔﺮ رﺷﺘﻪ دوم ﺑﺰرﮔﺘﺮ از رﺷﺘﻪ اول ﺑﺎﺷﺪ، ﺗﺎﺑﻊ ﻣﻘﺪار 1– را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﺑﺎ در ﻧﻈﺮ ﮔﺮﻓﺘﻦ ﺑﺰرگ ﻳﺎ آﻮﭼﻚ ﺑﻮدن ﺣﺮوف اﻧﺠﺎم ﻣﻲ ﺷﻮد.‬ ‫ﺑـــﺮاي اﻳﻨﻜـــﻪ ﺑـــﺰرگ ﻳـــﺎ آﻮﭼـــﻚ ﺑـــﻮدن ﺣـــﺮوف، در ﻣﻘﺎﻳـــﺴﻪ ﻧﺎدﻳـــﺪﻩ ﮔﺮﻓﺘـــﻪ ﺷـــﻮد، ﻣﻘـــﺪار‬ ‫ﺁرﮔﻮﻣﺎن ‪ Compare‬را ﺑﻪ ‪ CompareMethod.Text‬ﺗﻐﻴﻴﺮ دهﻴﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٢٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)”‪Result=StrComp(“Sybex”, “SYBEX‬‬ ‫ﭘﺲ از اﺟﺮاي اﻳﻦ دﺳﺘﻮر، ﻣﻘﺪار ‪ 1 ،Result‬ﺧﻮاهﺪ ﺷﺪ زﻳـﺮا ﻋﺒـﺎرت ‪ Sybex‬از ‪ SYBEX‬ﺑﺰرﮔﺘـﺮ‬ ‫اﺳﺖ و اﻳﻦ ﺑﺪان ﻋﻠﺖ اﺳﺖ آﻪ در ﺗﺮﺗﻴﺐ ﺣﺮوف اﺳﻜﻲ )‪ ،(ASCII‬ﺣﺮف ‪ y‬آﻮﭼﻚ ﺑﻌﺪ از ﺣﺮف ‪Y‬‬ ‫ﺑﺰرگ ﻗﺮار دارد. ﺑﻪ ﻋﺒﺎرت دﻳﮕﺮ ﺣﺮوف آﻮﭼﻚ ﺑﺮ ﺣﺮوف ﺑﺰرگ ارﺟﻌﻴﺖ دارﻧﺪ.‬ ‫ﻣﺜﺎل دﻳﮕﺮ:‬ ‫)‪Result=StrComp(“Sybex”, “SYBEX”, CompareMethod.Text‬‬ ‫اﻳﻦ هﻤﺎن ﻣﺜﺎل ﻗﺒﻠﻲ اﺳﺖ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ در اﻳﻦ ﻣﺜﺎل، ﺑﺰرگ و آﻮﭼﻚ ﺑـﻮدن ﺣـﺮوف ﺗـﺎﺛﻴﺮي در‬ ‫ﻧﺘﻴﺠﻪ ﻣﻘﺎﻳﺴﻪ ﻧﺨﻮاهﺪ داﺷﺖ ﭘﺲ دو رﺷﺘﻪ در اﻳﻦ ﺣﺎل ﺑﺎ ﻳﻜﺪﻳﮕﺮ ﺑﺮاﺑـﺮ ﺑـﻮدﻩ و ﻣﻘـﺪار ‪،Result‬‬ ‫0 ﺧﻮاهﺪ ﺷﺪ.‬ ‫)‪Left(string,number‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، از ﺳﻤﺖ ﭼﭗ ﻳﻚ رﺷﺘﻪ، رﺷﺘﻪ اي ﺑﺎ ﻃﻮل ﻣﻌﻴﻦ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،string‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺑﺎﻳﺪ رﺷﺘﻪ اي ﺑﻪ ﻃﻮل ﺗﻌﻴﻴﻦ ﺷـﺪﻩ در ﺁرﮔﻮﻣـﺎن ‪number‬‬ ‫از ﺳﻤﺖ ﭼﭗ ﺁن ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫”‪StrX=”Visual Basic.NET‬‬ ‫)6 ,‪StrGet=Left(StrX‬‬ ‫ﭘﺲ از اﺟﺮاي دﺳﺘﻮرات ﻓﻮق، 6 آﺎراآﺘﺮ اول از ﺳﻤﺖ ﭼﭗ ﻣﺘﻐﻴـﺮ ‪ StrX‬در ﻣﺘﻐﻴـﺮ ‪ StrGet‬ﻗـﺮار‬ ‫ﺧﻮاهﺪ ﮔﺮﻓﺖ و ﻣﻘﺪار ﻣﺘﻐﻴﺮ ‪ ،StrGet‬ﺑﺮاﺑﺮ ﺑﺎ ”‪ “Visual‬ﺧﻮاهﺪ ﺷﺪ.‬ ‫)‪Right(string,number‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، از ﺳﻤﺖ راﺳﺖ ﻳﻚ رﺷﺘﻪ، رﺷﺘﻪ اي ﺑﺎ ﻃﻮل ﻣﻌﻴﻦ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،string‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺑﺎﻳﺪ رﺷﺘﻪ اي ﺑﻪ ﻃﻮل ﺗﻌﻴﻴﻦ ﺷـﺪﻩ در ﺁرﮔﻮﻣـﺎن ‪number‬‬ ‫از ﺳﻤﺖ راﺳﺖ ﺁن ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫”‪StrX=”Visual Basic.NET‬‬ ‫)3 ,‪StrGet=Right(StrX‬‬ ‫ﭘﺲ از اﺟﺮاي دﺳﺘﻮرات ﻓـﻮق، 3 آـﺎراآﺘﺮ اول از ﺳـﻤﺖ راﺳـﺖ ﻣﺘﻐﻴـﺮ ‪ StrX‬در ﻣﺘﻐﻴـﺮ ‪StrGet‬‬ ‫ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ و ﻣﻘﺪار ﻣﺘﻐﻴﺮ ‪ ،StrGet‬ﺑﺮاﺑﺮ ﺑﺎ ”‪ “NET‬ﺧﻮاهﺪ ﺷﺪ.‬ ‫)] ‪Mid(string,start,[length‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺑﺨﺸﻲ از ﻳﻚ رﺷﺘﻪ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ string‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺑﺎﻳﺪ ﺑﺨﺸﻲ از ﺁن ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ start‬ﻣﻜﺎﻧﻲ از رﺷﺘﻪ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ اﺳﺘﺨﺮاج رﺷﺘﻪ ﺑﺎﻳـﺪ از ﺁن ﻣﻜـﺎن ﺷـﺮوع‬ ‫ﺷﻮد و ﺁرﮔﻮﻣﺎن ‪ length‬ﻃﻮل رﺷﺘﻪ ﺑﺮﮔﺸﺘﻲ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ.‬ ‫ﻧﻜﺎت ﻣﻬﻢ:‬ ‫١( اﺳﺘﺨﺮاج رﺷﺘﻪ از ﺳﻤﺖ ﭼﭗ ﺑﻪ راﺳﺖ اﻧﺠﺎم ﻣﻲ ﺷﻮد.‬ ‫٢( اﮔﺮ از ذآﺮ ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ length‬ﺧﻮدداري ﺷﻮد، ﺗﻤﺎﻣﻲ آﺎراآﺘﺮهﺎ از ﻣﻜﺎﻧﻲ آـﻪ ﺗﻮﺳـﻂ‬ ‫ﺁرﮔﻮﻣﺎن ‪ start‬ﻣﺸﺨﺺ ﺷﺪﻩ ﺗﺎ ﺑﻪ ﺁﺧﺮ رﺷﺘﻪ اﺳﺘﺨﺮاج ﻣﻲ ﺷﻮﻧﺪ.‬ ‫٣( اﮔﺮ ﻣﻘﺪار ﺁرﮔﻮﻣﺎن ‪ length‬ﺑﻴﺶ از ﺗﻌﺪاد آﺎراآﺘﺮهـﺎﻳﻲ ﺑﺎﺷـﺪ آـﻪ ﺑﻌـﺪ از ﺁرﮔﻮﻣـﺎن ‪ start‬در‬ ‫رﺷﺘﻪ وﺟﻮد دارﻧﺪ، ﺗﻤﺎﻣﻲ آﺎراآﺘﺮهﺎي ﻣﺸﺨﺺ ﺷﺪﻩ در رﺷﺘﻪ، از ﻣﻜـﺎن ‪ Start‬ﺗـﺎ ﺑـﻪ اﻧﺘﻬـﺎ‬ ‫ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫‪Mid(string,start [,length ])=new_string‬‬ ‫در ﺣﺎﻟﺖ ﭘﻴﺸﺮﻓﺘﻪ ﺗﺎﺑﻊ )(‪ Mid‬اﻳﻦ ﺗﺎﺑﻊ وﺟﻮد دارد آﻪ ﺗﺎ ﺣﺪي ﺷﺒﻴﻪ ﺑـﻪ ﺗـﺎﺑﻊ )(‪ Mid‬ﻋﻤـﻞ ﻣـﻲ‬ ‫آﻨﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٣٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫اﻳﻦ ﺗﺎﺑﻊ رﺷﺘﻪ اي را در ﻳﻚ رﺷﺘﻪ دﻳﮕﺮ ﺟﺎﻳﮕﺰﻳﻦ ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ string‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﻣﻘـﺪار ‪ new_String‬ﺑﺎﻳـﺪ در ﺁن ﺟـﺎﻳﮕﺰﻳﻦ ﺷـﻮد و ﺁرﮔﻮﻣـﺎن‬ ‫‪ Start‬ﻣﻮﻗﻌﻴﺘﻲ از ﺁرﮔﻮﻣﺎن )رﺷﺘﻪ( ‪ string‬را ﻣـﺸﺨﺺ ﻣـﻲ آﻨـﺪ آـﻪ ﻋﻤـﻞ ﺟـﺎﻳﮕﺰﻳﻨﻲ ﺑﺎﻳـﺪ از‬ ‫ﺁﻧﺠﺎ ﺷﺮوع ﺷﻮد و ﺁرﮔﻮﻣﺎن ‪ ،length‬ﻃﻮل رﺷﺘﻪ اي را آﻪ ﺑﺎﻳﺪ ﺟﺎﻳﮕﺰﻳﻦ ﺷﻮد ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ.‬ ‫ﻧﻜﺎت ﻣﻬﻢ:‬ ‫١( اﮔﺮ از ذآﺮ ﻣﻘﺪار ‪ new_string‬ﺧﻮدداري ﺷﻮد، ﺗﻤﺎﻣﻲ آﺎراآﺘﺮهـﺎ در رﺷـﺘﻪ از ﻧﻘﻄـﻪ ﺗﻌﻴـﻴﻦ‬ ‫ﺷﺪﻩ در ﺁن ﺗﺎ ﺑﻪ اﻧﺘﻬﺎ ﺟﺎﻳﮕﺰﻳﻦ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫٢( اﮔﺮ ﺑﺮﻧﺎﻣﻪ اي ﻣﻲ ﻧﻮﻳﺴﻴﺪ آﻪ ﺑﺎ رﺷﺘﻪ هﺎي ﻃﻮﻻﻧﻲ و ﻣﺘﻦ هﺎي زﻳﺎد ﺳـﺮ و آـﺎر دارد ﺣﺘﻤـﺎ‬ ‫از آﻼس ‪ StringBuilder‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﻣﺘﻐﻴﺮهﺎي آﻼس ‪ StringBuilder‬از ﻧﻮع ﻣﺘﻨﻲ)‪ (Text‬هﺴﺘﻨﺪ و آﺎﻣﭙـﺎﻳﻠﺮ ‪ .NET‬ﺑـﺴﻴﺎر ﺑﻬﺘـﺮ از‬ ‫ﻣﺘﻐﻴﺮهﺎي رﺷﺘﻪ اي )‪ (String‬ﻗﺎدر ﺑﻪ آﺎر ﺑﺎ ﺁﻧﻬﺎﺳﺖ. )آﻼس ﺑﺮﻧﺎﻣﻪ را هﻤﻴﺸﻪ ﺣﻔﻂ آﻨﻴﺪ!(‬ ‫)‪Len(string‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻃﻮل ﻳﻚ رﺷﺘﻪ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،string‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﻃﻮل ﺁن ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﻣﺜﺎل:‬ ‫)”‪Name =InputBox(“Enter your first name‬‬ ‫)‪NameLen =Len(Name‬‬ ‫ﺑﻌﺪ از اﺟﺮاي اﻳﻦ دﺳﺘﻮرات، ﻣﻘﺪار ﻣﺘﻐﻴﺮ ‪ ،NameLen‬ﻃـﻮل رﺷـﺘﻪ اي اﺳـﺖ آـﻪ آـﺎرﺑﺮ در آـﺎدر‬ ‫ﻣﺤﺎورﻩ )(‪ InputBox‬وارد آﺮدﻩ.‬ ‫از اﻳﻦ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺮاي ﭼـﻚ آـﺮدن اﻳﻨﻜـﻪ ﺁﻳـﺎ آـﺎرﺑﺮ ﻣﻘـﺪاري را در ﻣﻜـﺎﻧﻲ واردﻩ آـﺮدﻩ ﻳـﺎ ﻧـﻪ،‬ ‫اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل:‬ ‫‪If Len(Text1.Text) = 0 Then‬‬ ‫)”‪MsgBox (“Name field can ’t be empty‬‬ ‫‪Else‬‬ ‫)”‪MsgBox (“Thank you for registering‬‬ ‫‪EndIf‬‬ ‫در اﻳﻦ دﺳﺘﻮرات، ﻣﻘﺪار ‪ TextBox‬ﭼﻚ ﻣﻲ ﺷـﻮد آـﻪ ﺁﻳـﺎ آـﺎرﺑﺮ ﭼﻴـﺰي در ﺁن وارد آـﺮدﻩ ﻳـﺎ ﻧـﻪ و‬ ‫ﺳﭙﺲ ﭘﻴﻐﺎم ﻣﻨﺎﺳﺐ ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ Len‬ﻗﺎدر ﺑﻪ درﻳﺎﻓﺖ هﺮ ﻧﻮع ﻣﻘﺪار ﻏﻴﺮ رﺷﺘﻪ اي ﻧﻴﺰ در ﺁرﮔﻮﻣﺎن ‪ string‬ﺧﻮد ﻣﻲ ﺑﺎﺷﺪ.‬ ‫در اﻳﻦ ﺣﺎﻟﺖ ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ ﺗﺎﺑﻊ، ﺗﻌﺪاد ﺑﺎﻳﺖ هﺎي ﻣـﻮرد ﻧﻴـﺎز ﺟﻬـﺖ ﻧﮕﻬـﺪاري ﻣﻘـﺪار وارد‬ ‫ﺷﺪﻩ در ﺣﺎﻓﻈﻪ ﻣﻲ ﺑﺎﺷﺪ ﻧﻪ ﻃﻮل ﺁن.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل:‬ ‫)10.21(‪Len‬‬ ‫در ‪ ،VB.NET‬ﻣﻘﺎدﻳﺮ اﻋﺸﺎري ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض از ﻧﻮع ‪) Double‬اﻋﺸﺎري ﺑﺎ دﻗـﺖ ﻣـﻀﺎﻋﻒ(‬ ‫در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد ﭘﺲ ﺧﺮوﺟـﻲ ﺗـﺎﺑﻊ در اﻳـﻦ ﺣﺎﻟـﺖ، ﻋـﺪد 8 ﻳﻌﻨـﻲ ﺗﻌـﺪاد ﺑﺎﻳـﺖ هـﺎي ﻻزم‬ ‫ﺟﻬﺖ ﻧﮕﻬﺪاري ﻳﻚ ﻣﻘﺪار از ‪ Double‬در ﺣﺎﻓﻈﻪ ﺧﻮاهﺪ ﺑﻮد.‬ ‫و ﺑﻪ ﻋﻨﻮان ﺁﺧﺮﻳﻦ ﻣﺜﺎل:‬ ‫)21(‪Len‬‬ ‫در اﻳﻦ ﺣﺎﻟﺖ ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ، 4 ﺧﻮاهﺪ ﺑﻮد. زﻳﺮا ﻣﻴـﺰان ﻓـﻀﺎي ﻻزم ﺟﻬـﺖ ﻧﮕﻬـﺪاري ﻳـﻚ ﻋـﺪد از‬ ‫ﻧﻮع ‪ 4 ،Integer‬ﺑﺎﻳﺖ اﺳﺖ.‬ ‫)‪LTrim(string),RTrim(string),Trim(string‬‬ ‫اﻳﻦ ﺗﻮاﺑﻊ، ﻓﻀﺎهﺎي ﺧﺎﻟﻲ ﻳﻚ رﺷﺘﻪ را هﺮ آﺪام ﺑﻪ ﻧﺤﻮي ﺣﺬف ﻣﻲ آﻨﻨﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ ،LTrim‬ﻓﻀﺎي ﺧﺎﻟﻲ ﺳﻤﺖ ﭼﭗ ﻳﻚ رﺷﺘﻪ را ﺣﺬف ﻣﻲ آﻨﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ ،RTrim‬ﻓﻀﺎي ﺧﺎﻟﻲ ﺳﻤﺖ راﺳﺖ ﻳﻚ رﺷﺘﻪ را ﺣﺬف ﻣﻲ آﻨﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ ،Trim‬ﻓﻀﺎي ﺧﺎﻟﻲ ﺳﻤﺖ ﭼﭗ و راﺳﺖ ﻳﻚ رﺷﺘﻪ را ﺣﺬف ﻣﻲ آﻨﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٤٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﺁرﮔﻮﻣﺎن ‪ string‬در هﺮ ﺳﻪ ﺗﺎﺑﻊ، رﺷﺘﻪ اي اﺳﺖ آﻪ ﻓﻀﺎي ﺧﺎﻟﻲ ﺁن ﺑﺎﻳﺪ ﺣﺬف ﺷﻮد.‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ هﺮ ﺳﻪ ي اﻳﻦ ﺗﻮاﺑﻊ، ﻣﻘﺪاري رﺷﺘﻪ اي و از ﻧـﻮع ‪ String‬ﻣـﻲ ﺑﺎﺷـﺪ و ﻋﺒـﺎرﺗﻲ‬ ‫اﺳﺖ آﻪ ﻓﻀﺎهﺎي ﺧﺎﻟﻲ ﺁن ﺑﻨﺎ ﺑﻪ ﻧﻮع ﺗﺎﺑﻊ، ﺣﺬف ﺷﺪﻩ اﺳﺖ.‬ ‫آﺎرﺑﺮد اﻳﻦ ﺗﺎﺑﻊ ﻣﻌﻤﻮﻻ در ﭼـﻚ آـﺮدن ﻣﻘـﺎدﻳﺮ ورودي ﺗﻮﺳـﻂ آـﺎرﺑﺮ ﺑـﺮاي ﺗـﺸﺨﻴﺺ ﺧـﺎﻟﻲ ﻧﺒـﻮدن‬ ‫ﻣﻘﺪار ورودي اﺳﺖ.‬ ‫ﻣﺜﻼ دﺳﺘﻮرات زﻳﺮ ﭼﻚ ﻣﻲ آﻨﺪ آﻪ ﺁﻳـﺎ ﻣﻘـﺪار ﻣﺘﻐﻴـﺮ ‪ ،E_Mail‬ﺧـﺎﻟﻲ اﺳـﺖ ﻳـﺎ ﺧﻴـﺮ و در ﺻـﻮرت‬ ‫ﺧﺎﻟﻲ ﺑﻮدن ﺁن ﭘﻴﻐﺎﻣﻲ ﻇﺎهﺮ ﻣﻲ ﮔﺮدد.‬ ‫‪If E_Mail = “” Then‬‬ ‫)”‪MsgBox (“Applications without an e-mail address won ’t be processed‬‬ ‫‪End If‬‬ ‫ﺣﺎل در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ آﻪ آﺎرﺑﺮ ﺑﻪ ﺟﺎي ﺗﺎﻳﭗ آﺎراآﺘﺮي در ﻣﻜﺎن ﻣﻮرد ﻧﻈﺮ،ﻳﻚ ﻳـﺎ ﭼﻨـﺪﻳﻦ ﺑـﺎر از آﻠﻴـﺪ‬ ‫‪ Space‬اﺳﺘﻔﺎدﻩ آﻨﺪ. از ﺁﻧﺠﺎ آـﻪ ‪ Space‬ﻧﻴـﺰ ﻧـﻮﻋﻲ آـﺎراآﺘﺮ اﺳـﺖ ﭘـﺲ دﺳـﺘﻮرات ﺑـﺎﻻ آـﺎرﺑﺮد‬ ‫ﻧﺪارد.‬ ‫ﭘﺲ در اﻳﻦ ﺣﺎﻟﺖ ﺑﺮاي دﻗﺖ ﭼﻚ آﺮدن ﺑﺎﻳﺪ از ﺗﻮاﺑﻊ ﺑﺎﻻ اﺳﺘﻔﺎدﻩ آﺮد.‬ ‫ﻣﻌﻤﻮﻻ ﺗﺎﺑﻊ )(‪ Trim‬از دو ﺗﺎﺑﻊ دﻳﮕﺮ آﺎرﺑﺮد ﺑﻴﺸﺘﺮي دارد.‬ ‫ﭘﺲ دﺳﺘﻮرات ﺑﺎﻻ را ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺻﻼح ﻣﻲ آﻨﻴﻢ:‬ ‫‪If Trim(E_Mail)=“” Then‬‬ ‫)”!‪MsgBox (“Invalid Entry‬‬ ‫‪End If‬‬ ‫)‪Space(number‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ رﺷﺘﻪ آﺎراآﺘﺮي از ﻓﻀﺎي ﺧﺎﻟﻲ )‪ (Blanck‬اﻳﺠﺎد ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،number‬ﺗﻌﺪاد آﺎراآﺘﺮ ﻓﻀﺎي ﺧﺎﻟﻲ اﺳﺖ آﻪ ﺑﺎﻳﺪ اﻳﺠﺎد ﺷﻮد.‬ ‫اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ ﺧﺮوﺟﻲ هﺎي ﺑﺮﻧﺎﻣﻪ و اﻳﺠـﺎد ﺑـﺎﻓﺮ ﺑـﺮاي ﺑﺮﺧـﻲ از ﺗﻮاﺑـﻊ‬ ‫‪ API‬ﻣﻔﻴﺪ اﺳﺖ.‬ ‫)‪StrDup(number,character‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ آﺎراآﺘﺮ را در ﻳﻚ رﺷﺘﻪ ﺑﻪ ﺗﻌﺪاد ﻣﻌﻴﻦ ﺑﺎر ﺗﻜﺮار ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ number‬ﻋﺪدي اﺳﺖ آﻪ ﺗﻌـﺪاد ﺗﻜـﺮار آـﺎراآﺘﺮ را آـﻪ ﺑـﻪ وﺳـﻴﻠﻪ ﺁرﮔﻮﻣـﺎن ‪character‬‬ ‫ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد، ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ character‬ﻣﻲ ﺗﻮاﻧﺪ آﺎراآﺘﺮ ﻳﺎ آﺪ اﺳﻜﻲ ﺑﺎﺷﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺟﺎﻳﮕﺰﻳﻦ ﺗﺎﺑﻊ )(‪ String‬در 0.6.‪ VB‬ﺷﺪﻩ اﺳﺖ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)”*“ ,21(‪Result=StrDup‬‬ ‫ﺑﺎ اﺟﺮاي اﻳﻦ دﺳﺘﻮر، آﺎراآﺘﺮ )*( ﺑﻪ ﺗﻌﺪاد 21 ﺑﺎر ﺗﻜـﺮار ﺧﻮاهـﺪ ﺷـﺪ و ﻧﺘﻴﺠـﻪ در ﻣﺘﻐﻴـﺮ ‪Result‬‬ ‫ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ. ﻳﻌﻨﻲ ﻣﺘﻐﻴﺮ ‪ Result‬داراي ﻣﻘﺪار زﻳﺮ ﺧﻮاهﺪ ﺷﺪ:‬ ‫”************”=‪Result‬‬ ‫)‪StrConv(string,conversion‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي را آﻪ ﺑﻪ ﺷﻜﻞ دﻳﮕﺮي ﺗﺒﺪﻳﻞ ﺷﺪﻩ اﺳﺖ ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،string‬رﺷﺘﻪ اي اﺳـﺖ آـﻪ ﺑﺎﻳـﺪ ﺗﺒـﺪﻳﻞ ﺷـﻮد و ﺁرﮔﻮﻣـﺎن ‪ conversion‬ﻧـﻮع ﺗﺒـﺪﻳﻞ را‬ ‫ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ ﻣﻲ ﺗﻮاﻧﺪ ﻳﻜﻲ از ﻣﻮارد زﻳﺮ ﺑﺎﺷﺪ:‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ convesion‬در ﺗﺎﺑﻊ )(‪StrConv‬‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻣﻘﺪار‬ ‫ﺗﻤﺎﻣﻲ آﺎراآﺘﺮهﺎي ﻣﻮﺟﻮد در رﺷﺘﻪ ﺑـﻪ ﺣـﺮوف‬ ‫‪UpperCase‬‬ ‫ﺑﺰرگ ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫ﺗﻤﺎﻣﻲ آﺎراآﺘﺮهﺎي ﻣﻮﺟﺪ در رﺷـﺘﻪ ﺑـﻪ ﺣـﺮوف‬ ‫‪LowerCase‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٥٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫آﻮﭼﻚ ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫اوﻟﻴﻦ آﺎراآﺘﺮ هﺮ آﻠﻤﻪ در رﺷﺘﻪ ﺑﻪ ﺣﺮف ﺑـﺰرگ‬ ‫‪ProperCase‬‬ ‫ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮد.‬ ‫آﺎراآﺘﺮهﺎي ﺗﻚ ﺑﺎﻳﺘﻲ در رﺷﺘﻪ ﺑﻪ آﺎراآﺘﺮهـﺎي‬ ‫‪Wide Narrow‬‬ ‫دوﺑﺎﻳﺘﻲ ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ‬ ‫آﺎراآﺘﺮهﺎي دوﺑﺎﻳﺘﻲ در رﺷـﺘﻪ ﺑـﻪ آﺎراآﺘﺮهـﺎي‬ ‫‪Narrow‬‬ ‫ﺗﻚ ﺑﺎﻳﺘﻲ ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫آﺎراآﺘﺮهـــ ـﺎي ‪ Hiragana‬ﺑـــ ـﻪ آﺎراآﺘﺮهـــ ـﺎي‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫‪Katakana‬‬ ‫‪ Katakana‬ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫آﺎراآﺘﺮهــــﺎي ‪ Katakana‬ﺑــــﻪ آﺎراآﺘﺮهــــﺎي‬ ‫‪Hiragana‬‬ ‫‪ Hiragana‬ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫آﺎراآﺘﺮهـ ـﺎي ﺳـ ـﺎدﻩ ﭼﻴﻨـ ـﻲ ﺑـ ـﻪ آﺎراآﺘﺮهـ ـﺎي‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫‪Traditional‬‬ ‫ﺳﻨﺘﻲ ﭼﻴﻨﻲ ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫آﺎراآﺘﺮهــﺎي ﺳــﻨﺘﻲ ﭼﻴﻨــﻲ ﺑــﻪ آﺎراآﺘﺮهــﺎي‬ ‫‪Simplified‬‬ ‫ﺳﺎدﻩ ﭼﻴﻨﻲ ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ‬ ‫ﺑﺮاي ﺗﺒﺪﻳﻞ هﺎي ﭼﻨﺪﺗﺎﻳﻲ ﻣﻲ ﺗﻮاﻧﻴﺪ اﻳﻦ ﻣﻘﺎدﻳﺮ را ﺑﺎ ﻋﻼﻣﺖ + ﺑﺎ هﻢ ‪ AND‬آﻨﻴﺪ.‬ ‫ﺑﻪ ﻣﺜﺎل زﻳﺮ ﺗﻮﺟﻪ آﻨﻴﺪ:‬ ‫)‪newString =StrConv(MyString, vbStrConv.LowerCase + vbStrConv.Unicode‬‬ ‫در اﻳﻦ دﺳﺘﻮر، ﻋﺒﺎرت ﻣﻮﺟﻮد در ﻣﺘﻐﻴـﺮ ‪ ،MyString‬ﺑـﻪ ﺣـﺮوف آﻮﭼـﻚ و ﻗﺎﻟـﺐ ‪ Unicode‬ﺗﺒـﺪﻳﻞ‬ ‫ﺧﻮاهﺪ ﺷﺪ.‬ ‫)‪StrReverse(string‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي را ﻣﻌﻜﻮس ﻣﻲ آﻨﺪ.‬ ‫ﻣﺜﺎل:‬ ‫)”‪Result=StrReverse(“VisualBasic‬‬ ‫ﭘﺲ از اﺟﺮاي اﻳﻦ دﺳﺘﻮر، ﻣﻘﺪار ﻣﺘﻐﻴﺮ ‪ Result‬ﺑﺮاﺑﺮ ﺑﺎ ”‪ “lausiVcisaB‬ﺧﻮاهﺪ ﺷﺪ.‬ ‫)] ‪Filter(inputStrings,value [,include ][,compare‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺑﻴﺎن ﺳﺎدﻩ ﻳﻚ رﺷﺘﻪ ﻳﺎ زﻳﺮرﺷﺘﻪ را در ﻳﻚ ﺁراﻳﻪ رﺷـﺘﻪ اي ﺟـﺴﺘﺠﻮ آـﺮدﻩ و در ﺻـﻮرت‬ ‫ﭘﻴﺪا آﺮدن ﺁن، ﻳﻚ ﺁراﻳﻪ را ﺑﻪ ﻋﻨﻮان ﺧﺮوﺟﻲ ﻣﻲ دهﺪ آﻪ ﺧﺎﻧﻪ ﻳﺎ ﺧﺎﻧﻪ هﺎي ﺁن ﺗﺎ اﻧﺪﻳﺲ ﻣﻘﺪاري‬ ‫آﻪ در ﺁراﻳﻪ اﺻﻠﻲ ﭘﻴﺪا ﺷﺪﻩ و ﺑﺎ ﺁن ﻣﻘﺪار ﭘﺮ ﻣﻲ ﺷﻮد.‬ ‫در ﺣﻘﻴﻘﺖ ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ آﻪ در ﺁراﻳﻪ ﻗﺮار ﻣﻲ ﮔﻴـﺮد، ﺷـﺎﻣﻞ ﻳﻜـﻲ از ﻣﻘـﺎدﻳﺮ ﺧﺎﻧـﻪ هـﺎي ﺁراﻳـﻪ‬ ‫ﺟﺴﺘﺠﻮ ﺷﻮﻧﺪﻩ اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،inputstring‬ﻳﻚ ﺁراﻳﻪ ﻳﻚ ﺑﻌﺪي و رﺷﺘﻪ اي اﺳﺖ آﻪ ﻋﻤﻞ ﺟﺴﺘﺠﻮ ﺑﺎﻳـﺪ در ﺁن اﻧﺠـﺎم‬ ‫ﺷﻮد. دﻗﺖ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ اﻳﻦ ﺁراﻳﻪ ﺣﺘﻤﺎ ﺑﺎﻳﺪ ﺑﻪ ﺻﻮرت ﻳﻚ ﺑﻌﺪي ﺗﻌﺮﻳﻒ ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ value‬ﻣﻘﺪاري رﺷﺘﻪ اي اﺳﺖ آﻪ ﺟﺴﺘﺠﻮ ﺑﺎﻳﺪ ﺑﺮاي ﺁن اﻧﺠﺎم ﺷﻮد.‬ ‫دو ﺁرﮔﻮﻣﺎن ﺁﺧﺮ، اﺧﺘﻴﺎري هﺴﺘﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ include‬ﻣﺸﺨﺺ ﻣﻲ آﻨﻪ آﻪ ﺁﻳﺎ آﻞ ﻣﻘﺪار ‪ value‬ﺑﺎﻳﺪ در ﺁراﻳﻪ ﺑﺎﺷﺪ ﻳـﺎ ﻗـﺴﻤﺘﻲ از ﺁن‬ ‫هﻢ ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ ﻋﻨﻮان ﺷﺮط ﺟﺴﺘﺠﻮ ﺑﻪ آﺎر رود و ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ ‪ True‬ﻳﺎ ‪ False‬را ﻣﻲ ﭘﺬﻳﺮد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،compare‬ﻧﻮع ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ و ﻣـﺸﺨﺺ ﻣـﻲ آﻨـﺪ آـﻪ ﺁﻳـﺎ ﺑـﺰرگ ﻳـﺎ‬ ‫آﻮﭼــﻚ ﺑــﻮدن ﺣــﺮوف ﺗــﺎﺛﻴﺮي در ﻣﻘﺎﻳــﺴﻪ و ﺟــﺴﺘﺠﻮ داﺷــﺘﻪ ﺑﺎﺷــﺪ ﻳــﺎ ﺧﻴــﺮ و ﻳﻜــﻲ از ﻣﻘــﺎدﻳﺮ‬ ‫‪) CompareMethod.Binary‬ﭘــــﻴﺶ ﻓــــﺮض ﻳﻌﻨــــﻲ در ﻧﻈــــﺮ ﮔﺮﻓﺘــــﻪ ﻣــــﻲ ﺷــــﻮد( و ﻳــــﺎ‬ ‫‪) CompareMethod.Text‬ﻳﻌﻨﻲ در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻧﻤﻲ ﺷﻮد( را ﻣﻲ ﭘﺬﻳﺮد.‬ ‫ﺗﻌﺪاد ﺧﺎﻧﻪ هﺎي ﺁراﻳﻪ ي ﺑﺮﮔﺸﺖ دادﻩ ﺷﺪﻩ ﺑﺴﺘﮕﻲ ﺑﻪ اﻧﺪﻳﺲ ﻣﺤﻞ وﺟﻮد رﺷﺘﻪ اي اﺳـﺖ آـﻪ‬ ‫در ﺁراﻳﻪ ﭘﻴﺪا ﺷﺪﻩ. ﻓﺮﺿﺎ اﮔﺮ ﻣﻘﺪار ﻣﻮرد ﻧﻈﺮ ﻣﺎ در ﺧﺎﻧﻪ ي 4 ﺁراﻳﻪ ﭘﻴـﺪا ﺷـﺪ، ﺗﻌـﺪاد ﺧﺎﻧـﻪ هـﺎي‬ ‫ﺁراﻳﻪ ﺑﺮﮔﺸﺘﻲ 4 ﺧﺎﻧﻪ ﺧﻮاهﺪ ﺑﻮد.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٦٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﭘﺲ، از ﺁﻧﺠﺎ آﻪ ﺧﺎﻧﻪ اي آﻪ ﻣﻘﺪار ﻣﻮرد ﻧﻈﺮ در ﺁن ﭘﻴﺪا ﻣﻲ ﺷﻮد از ﻗﺒﻞ ﻗﺎﺑﻞ ﭘﻴﺶ ﺑﻴﻨﻲ ﻧﻴـﺴﺖ‬ ‫ﻧﺒﺎﻳﺪ ﺑﺮاي ﺧﺎﻧﻪ هﺎي ﺁراﻳﻪ ﺑﺮﮔﺸﺘﻲ، ﺗﻌﺪاد ﺗﻌﺮﻳﻒ آﻨﻴﻢ و ﻳﺎ ﺑﻪ ﻋﺒﺎرت دﻳﮕـﺮ ﺑﺎﻳـﺪ ﻳـﻚ ﺁراﻳـﻪ ﺑـﺪون‬ ‫ﺑﻌﺪ ﺗﻌﺮﻳﻒ آﻨﻴﻢ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫‪Dim selNames()As String‬‬ ‫}”‪Dim Names()As String ={“Ali”, “Mehdi”, “Mehdi”, “Behrouz”, “Sina‬‬ ‫در اﻳﻦ ﻣﺜﺎل، ﺁراﻳﻪ اي ﺑﻪ ﻧﺎم ‪ Names‬ﺗﻌﺮﻳﻒ ﺷﺪﻩ آﻪ ﭘﻨﺞ ﺧﺎﻧﻪ ي اول ﺁن ﺑﺎ 5 ﻣﻘـﺪار رﺷـﺘﻪ اي‬ ‫ﭘﺮ ﺷﺪﻩ اﺳﺖ. اﻳﻦ ﺁراﻳﻪ اي اﺳﺖ آﻪ ﻣﺎ در ﺁن ﻗﺼﺪ ﺟﺴﺘﺠﻮي ﻣﻘﺪار ﺧﻮد را دارﻳﻢ.‬ ‫ﺣﺎل ﻣﻲ ﺧﻮاهﻴﻢ ﻣﻘﺪار ذﺧﻴـﺮﻩ ﺷـﺪﻩ در ﻣﺘﻐﻴـﺮي رﺷـﺘﻪ اي ﺑـﻪ ﻧـﺎم ‪ myName‬را در اﻳـﻦ ﺁراﻳـﻪ‬ ‫ﺟﺴﺘﺠﻮ آﻨﻴﻢ. ﭘﺲ ﺗﺎﺑﻊ )(‪ Filter‬را ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ آﻨﻴﻢ:‬ ‫)‪selNames =Filter(Names,myName‬‬ ‫ﭘﺲ از اﺟﺮاي اﻳﻦ دﺳـﺘﻮر اﮔـﺮ ﻣﻘـﺪار ذﺧﻴـﺮﻩ ﺷـﺪﻩ در ﻣﺘﻐﻴـﺮ ‪ myName‬در ﺁراﻳـﻪ ﻧﺒﺎﺷـﺪ، در ﺁن‬ ‫ﺻﻮرت ﺁراﻳﻪ ‪ selNames‬آﻪ ﺁن را ﺑﻪ ﺻﻮرت ﺁراﻳﻪ اي ﺑﺪون ﺑﻌﺪ ﺗﻌﺮﻳﻒ آﺮدﻳﻢ ﺁراﻳﻪ اي ﺑـﺪون ﺧﺎﻧـﻪ‬ ‫ﺧﻮاهﺪ ﺑﻮد و ﻳﺎ ﺑﻪ ﻋﺒﺎرت دﻳﮕﺮ ﺧﺎﺻﻴﺖ ‪ Length‬ﺁن ﺑﺮاﺑﺮ ﺑﺎ 0 ﺧﻮاهﺪ ﺑﻮد.‬ ‫اﮔﺮ ﻣﻘﺪار ذﺧﻴـﺮﻩ ﺷـﺪﻩ در ﻣﺘﻐﻴـﺮ ‪ “Ali” ،myName‬ﺑﺎﺷـﺪ، ﺣـﺪ ﺑـﺎﻻي ﺁراﻳـﻪ ‪ selNames‬ﺻـﻔﺮ‬ ‫ﺧﻮاهﺪ ﺑﻮد و ﻣﻘﺪار اوﻟﻴﻦ ﺧﺎﻧﻪ ﺁراﻳﻪ ﺑﺮاﺑﺮ ﺑﺎ ”‪ “Ali‬ﻣﻲ ﺷﻮد ﻳﻌﻨﻲ: ”‪selNames(0)=”Ali‬‬ ‫اﮔﺮ ﻣﻘﺪار ذﺧﻴﺮﻩ ﺷﺪﻩ در ﻣﺘﻐﻴﺮ ‪ “Mehdi” ،myName‬ﺑﺎﺷﺪ، ﺣﺪ ﺑـﺎﻻي ﺁراﻳـﻪ ‪ ،selNames‬ﻳـﻚ‬ ‫ﺧﻮاهﺪ ﺑﻮد و ﻣﻘﺎدﻳﺮ ﺧﺎﻧﻪ هﺎي اول و دوم ﺁراﻳﻪ ﺑﺮاﺑﺮ ﺑﺎ ”‪ “Mehdi‬ﻣﻲ ﺷﻮد ﻳﻌﻨﻲ:‬ ‫”‪selNames(0)=”Mehdi‬‬ ‫”‪selNames(1)=”Mehdi‬‬ ‫)] ‪Replace(expression,find,replacewith [,start ][,count ][,compare‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ رﺷﺘﻪ را در رﺷﺘﻪ دﻳﮕـﺮ ﺟـﺴﺘﺠﻮ آـﺮدﻩ و رﺷـﺘﻪ ﺳـﻮم را ﺟـﺎﻳﮕﺰﻳﻦ رﺷـﺘﻪ ﺟـﺴﺘﺠﻮ‬ ‫ﺷﺪﻩ ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺑﺮاي ﺟﺎﻳﮕﺰﻳﻨﻲ ﺟﺴﺘﺠﻮ ﻣﻲ ﮔﺮدد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،find‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺟﺴﺘﺠﻮ ﻣﻲ ﮔﺮدد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،replacewith‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺟﺎﻳﮕﺰﻳﻦ رﺷﺘﻪ ﭘﻴﺪا ﺷﺪﻩ ﻣﻲ ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،start‬ﻋﺪدي اﺳﺖ آﻪ ﻣﻜﺎن ﺷﺮوع ﺟﺴﺘﺠﻮ در رﺷﺘﻪ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨـﺪ و اﮔـﺮ‬ ‫در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻧﺸﻮد، ﺟﺴﺘﺠﻮ از اﺑﺘﺪاي رﺷﺘﻪ ﺷﺮوع ﻣﻲ ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،count‬ﻣﻘﺪاري ﻋﺪدي اﺳﺖ آﻪ ﺗﻌﺪاد دﻓﻌﺎﺗﻲ را آﻪ ﺟﺎﻳﮕﺰﻳﻨﻲ ﺑﺎﻳﺪ اﻧﺠﺎم ﮔﻴﺮد، ﺗﻌﻴـﻴﻦ‬ ‫ﻣﻲ آﻨﺪ. اﮔﺮ ذآﺮ ﻧﺸﻮد، آﻠﻴﻪ ﺟﺎﻳﮕﺰﻳﻨﻲ هﺎ اﻧﺠﺎم ﺧﻮاهﺪ ﺷﺪ.‬ ‫و در ﻧﻬﺎﻳﺖ ﺁرﮔﻮﻣﺎن ‪ ،compare‬ﻧﻮع ﻣﻘﺎﻳﺴﻪ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آـﻪ در ﺗﻮاﺑـﻊ ﻗﺒﻠـﻲ در ﻣـﻮرد اﻳـﻦ‬ ‫ﺁرﮔﻮﻣﺎن ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫”‪S=”Visual Basic.NET as powerfull as C#.NET‬‬ ‫)”‪K=Replace (S, “NET”, “bes‬‬ ‫)‪Console.WriteLn(K‬‬ ‫ﺧﺮوﺟﻲ اﻳﻦ ﻗﻄﻌﻪ ﺑﺮﻧﺎﻣﻪ ﭘﺲ از اﺟﺮا ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺧﻮاهﺪ ﺑﻮد:‬ ‫”‪”Visual Basic.bes as powerfull as C#.bes‬‬ ‫)] ‪Join(list [,delimiter‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻣﻘﺎدﻳﺮ ﻣﻮﺟﻮد در ﻳﻚ ﺁراﻳﻪ ﻳﻚ ﺑﻌﺪي – رﺷﺘﻪ اي را ﺑﻪ ﺻﻮرت ﻳﻚ رﺷﺘﻪ و ﭘﺸﺖ ﺳﺮ هﻢ‬ ‫ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،list‬ﺁراﻳﻪ اي ﻳﻚ ﺑﻌﺪي و ﺷﺎﻣﻞ ﻣﻘﺎدﻳﺮي رﺷﺘﻪ اي اﺳـﺖ آـﻪ ﻗـﺼﺪ ﺑﺎزﮔـﺸﺖ ﺁﻧﻬـﺎ ﺑـﻪ‬ ‫ﺻﻮرت ﻳﻚ رﺷﺘﻪ را دارﻳﺪ و ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،delimiter‬ﻳﻚ آـﺎراآﺘﺮ رﺷـﺘﻪ اي اﺳـﺖ آـﻪ ﺑـﺮاي‬ ‫ﺟﺪا آﺮدن رﺷﺘﻪ هﺎ از هﻢ در ﻧﺘﻴﺠﻪ ﺧﺮوﺟﻲ ﺑـﻪ آـﺎر ﻣـﻲ رود و در ﺻـﻮرﺗﻲ آـﻪ ذآـﺮ ﻧـﺸﻮد، ﻳـﻚ‬ ‫ﻓﺎﺻﻠﻪ ﺧﺎﻟﻲ در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد و اﮔﺮ ﻣﻘﺪار ﺁن ﺗﻬﻲ ﻳﺎ ”“ ﺗﻌﻴﻴﻦ ﺷـﻮد، ﻣﻘـﺎدﻳﺮ ﺧﺎﻧـﻪ هـﺎي‬ ‫ﺁراﻳﻪ ﭘﺸﺖ ﺳﺮ هﻢ و ﺑﺪون ﻓﺎﺻﻠﻪ در ﺧﺮوﺟﻲ ﻇﺎهﺮ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫‪Dim MyArr(1 To 5) As String‬‬ ‫‪Dim Result As String‬‬ ‫”‪MyArr(1) = "Behrouz‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٧٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫”‪MyArr(2) = "Rad‬‬ ‫)”|“ ,‪Result = Join(MyArr‬‬ ‫‪MsgBox Result‬‬ ‫ﺑﻌﺪ از اﺟﺮاي اﻳﻦ دﺳﺘﻮرات، ﺧﺮوﺟﻲ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ:‬ ‫”|||‪“Behrouz|Rad‬‬ ‫دﻗﺖ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ اﮔﺮ ﺗﻤﺎم ﺧﺎﻧﻪ هﺎي ﺁراﻳﻪ ﭘﺮ ﻧﺸﺪﻩ ﺑﺎﺷﻨﺪ، ﺑﻪ ﺟـﺎي ﺁﻧﻬـﺎ آـﺎراآﺘﺮي آـﻪ در‬ ‫ﺁرﮔﻮﻣﺎن ‪ delimiter‬ﺗﻌﻴﻴﻦ ﺷﺪﻩ ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ.‬ ‫ﺗﻌﺪاد آﺎراآﺘﺮهﺎي ‪ delimiter‬آﻪ ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ، ﺗﻌﺪاد ﺧﺎﻧﻪ هﺎي ﺁراﻳﻪ ﻣﻨﻬﺎي ﻳﻚ اﺳﺖ.‬ ‫)] ‪Split(expression [,delimiter ][,count ][,compare‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ رﺷﺘﻪ را ﺑﻪ ﺗﻌﺪادي زﻳﺮرﺷﺘﻪ ي آﻮﭼﻜﺘﺮ ﺗﻘﺴﻴﻢ آﺮدﻩ و هﺮ آﺪام را در ﻳﻜﻲ از ﺧﺎﻧـﻪ‬ ‫هﺎي ﺁراﻳﻪ ﻗﺮار ﻣﻲ دهﺪ و ﻳﺎ ﺑﻪ ﻋﺒﺎرت ﺑﻬﺘﺮ هﺮ آﺪام از آﻠﻤﺎت رﺷﺘﻪ را در ﻳﻚ ﺧﺎﻧﻪ ي ﺁراﻳـﻪ ﻗـﺮار‬ ‫ﻣﻲ دهﺪ.‬ ‫ﺧﺮوﺟﻲ اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﺁراﻳﻪ ﻳﻚ ﺑﻌﺪي اﺳﺖ آﻪ هـﺮ آـﺪام از ﺧﺎﻧـﻪ هـﺎي ﺁن داراي ﻳﻜـﻲ از ﻣﻘـﺎدﻳﺮ‬ ‫زﻳﺮرﺷﺘﻪ هﺎﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺑﺎﻳﺪ ﺑﻪ زﻳﺮرﺷﺘﻪ هﺎي آﻮﭼﻜﺘﺮ ﺗﻘﺴﻴﻢ ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،delimiter‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺗﻘﺴﻴﻢ ﺑﻨﺪي ﺑﺎﻳﺪ ﺑـﺮ اﺳـﺎس ﺁن اﻧﺠـﺎم ﺷـﻮد.‬ ‫اﮔﺮ ذآﺮ ﻧﺸﻮد ﻓﻀﺎي ﺧﺎﻟﻲ در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد وﻟﻲ اﮔﺮ ﺗﻬﻲ ﻳﺎ ”“ ذآﺮ ﺷﻮد، آﻞ رﺷـﺘﻪ در‬ ‫اوﻟﻴﻦ ﻋﻨﺼﺮ ﺁراﻳﻪ ﻗﺮار ﻣﻲ ﮔﻴﺮد.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ count‬ﻧﻴﺰ ﺗﻌﺪاد زﻳﺮرﺷﺘﻪ هﺎﻳﻲ را آﻪ ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷـﻮﻧﺪ ﻣـﺸﺨﺺ ﻣـﻲ‬ ‫آﻨﺪ.‬ ‫اﮔﺮ ﻣﻘﺪار ﺁن 1– ﺑﺎﺷﺪ، ﺗﻤﺎﻣﻲ زﻳﺮرﺷﺘﻪ هﺎ ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ compare‬آﻪ ﻧﻮع ﻣﻘﺎﻳﺴﻪ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ در ﺗﻮاﺑﻊ ﻗﺒﻠﻲ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫ﻓﺮض ﻣﻲ آﻨﻴﻢ ﻣﺘﻐﻴﺮي رﺷﺘﻪ اي ﺑﻪ ﻧﺎم ‪ path‬ﺗﻌﺮﻳﻒ آﺮدﻩ اﻳﻢ آﻪ ﻣﻘـﺪار زﻳـﺮ در ﺁن ﻗـﺮار ﮔﺮﻓﺘـﻪ‬ ‫اﺳﺖ:‬ ‫”‪path =“c:windesktopDotNetExamplesControls‬‬ ‫ﺗﺎﺑﻊ )(‪ Split‬در اﻳﻦ ﺣﺎﻟﺖ ﻣﻲ ﺗﻮاﻧﺪ هﺮ ﻳﻚ اﺟـﺰاي اﻳـﻦ ﻣﻘـﺪار را آـﻪ ﺑـﺎ آـﺎراآﺘﺮ )( از هـﻢ ﺟـﺪا‬ ‫ﺷﺪﻩ اﻧﺪ ﺑﺎ دﺳﺘﻮر زﻳﺮ ﺟﺪا آﺮدﻩ و در ﺧﺎﻧﻪ هﺎي ﻳﻚ ﺁراﻳﻪ ﺑﻪ ﻧﺎم ‪ parts‬ﻗﺮار دهﺪ:‬ ‫)”“,” ‪parts =Split(“c:win desktop DotNet Examples Controls‬‬ ‫ﺣﺎل ﺑﺎ دﺳﺘﻮرات زﻳﺮ ﻣﻲ ﺗﻮاﻧﻴﻢ ﻧﺘﻴﺠﻪ آﺎر را ﻣﺸﺎهﺪﻩ آﻨﻴﻢ:‬ ‫)0(‪For i =0 To parts.GetUpperBound‬‬ ‫))‪Console.WriteLine(parts(i‬‬ ‫‪Next‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٨٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)‪:(Data Formatting‬‬ ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ دادﻩ هﺎ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‬ ‫‪ VB.NET‬ﺗﻤـﺎﻣﻲ ﺗـﻮاﺑﻌﻲ آ ـﻪ در 0.6.‪ VB‬ﺑـﺮاي ﻗﺎﻟـﺐ ده ـﻲ ﺑـﻪ دادﻩ هـﺎ ﺑ ـﻪ آـﺎر ﻣـﻲ روﻧ ـﺪ را‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ﭘﺸﺘﻴﺒﺎﻧﻲ ﻣﻲ آﻨﺪ.‬ ‫)]]] ‪Format(expression [,format [,firstdayofweek [,firstweekofyear‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ دﻟﻴﻞ اهﻤﻴﺖ و ﮔﺴﺘﺮﮔﻲ زﻳﺎدي آـﻪ دارد، ﺗـﺎﺑﻌﻲ اﺳـﺖ آـﻪ در اﻳـﻦ آﺘـﺎب، ﺑﻴـﺸﺘﺮﻳﻦ‬ ‫ﺗﻮﺿﻴﺤﺎت در ﻣﻮرد ﺁن دادﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﻣﻘﺪار را ﺑﺎ ﻓﺮﻣﺖ ﺧﺎﺻﻲ ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺑﻪ ﺑﻴﺎن ﺳﺎدﻩ، اﻳﻦ ﺗﺎﺑﻊ ﺷﻴﻮﻩ ﻧﻤﺎﻳﺶ اﻋﺪاد، رﺷﺘﻪ هـﺎ و ﻣﻘـﺎدﻳﺮ ﺗـﺎرﻳﺦ و زﻣـﺎن را ﻣـﺸﺨﺺ ﻣـﻲ‬ ‫آﻨﺪ.‬ ‫ﺁرﮔﻮﻣـﺎن ‪ ،expression‬ﻣـﻲ ﺗﻮاﻧـﺪ ﻳـﻚ ﻋـﺪد، رﺷـﺘﻪ ﻳـﺎ ﻣﻘـﺪاري از ﻧـﻮع ﺗـﺎرﻳﺦ ﺑﺎﺷـﺪ و ﺁرﮔﻮﻣـﺎن‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫‪ ،Format‬ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي اﺳﺖ آﻪ ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ ﺗﺎﺑﻊ ﻣﺎ ﻣﻘﺪار ﺧﺮوﺟﻲ را ﺑﺎ ﭼﻪ ﻗﺎﻟﺐ ﻳﺎ‬ ‫ﻓﺮﻣﺘﻲ ﺑﺮﮔﺸﺖ و ﻧﻤﺎﻳﺶ دهﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔـﺮ ﻣﻘـﺪار ورودي ﻣـﺎ ﻳﻌﻨـﻲ ﻣﻘـﺪار ﺁرﮔﻮﻣـﺎن ‪ expression‬از ﻧـﻮع زﻣـﺎن )‪(Time‬‬ ‫ﺑﺎﺷﺪ و ﻗﺎﻟﺐ ﺁرﮔﻮﻣﺎن ‪ format‬را ﺑﻪ ﺷﻜﻞ ”‪ “hh:mm:ss‬اﻧﺘﺨﺎب آﺮدﻩ ﺑﺎﺷـﻴﻢ، ﺧﺮوﺟـﻲ ﺗـﺎﺑﻊ،‬ ‫زﻣﺎن ﺣﺎل را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ. ﻣﺜﻼ: ”73:22:81“‬ ‫ﺑـﻪ ﻋﻨـﻮان ﻣﺜـﺎﻟﻲ دﻳﮕـﺮ، ﻓﺮﻣـﺎن زﻳـﺮ ، ﻣﻘـﺪار ‪ pi‬را ﺑـﻪ ﺷـﻜﻞ ﻋـﺪدي اﻋـﺸﺎري ﺑـﺎ دﻗـﺖ ﻣـﻀﺎﻋﻒ‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫)‪ (Double‬ﻣﺤﺎﺳﺒﻪ ﻣﻲ آﻨﺪ.‬ ‫)4*)1(‪Console.WriteLine(Math.Atan‬‬ ‫ﻧﺘﻴﺠﻪ ﺧﺮوﺟﻲ، ﻋﺪد ”97985356295141.3“ ﺧﻮاهﺪ ﺑﻮد.‬ ‫اﻳﻦ ﻧﺘﻴﺠﻪ ي ﺧﻮﺑﻲ اﺳﺖ اﻣﺎ اﮔﺮ ﻗﺮار ﺑﺎﺷﺪ اﻳﻦ ﻋﺪد در ﻳـﻚ ‪ TextBox‬ﻗـﺮار ﺑﮕﻴـﺮد آـﻪ ﺑـﺮاي ﺁن‬ ‫ﻣﺤﺪودﻳﺘﻲ از ﻟﺤﺎظ ﺗﻌﺪاد آﺎراآﺘﺮهﺎي ورودي ﻗﺎﺋﻞ ﺷﺪﻩ اﻳﺪ و اﻳﻦ ﻣﻘﺪار آﻤﺘﺮ از ﺗﻌـﺪاد ارﻗـﺎم اﻳـﻦ‬ ‫ﻋﺪد ﺑﺎﺷﺪ، ﺗﻤﺎﻣﻲ ارﻗﺎم در ‪ TextBox‬ﻗﺮار ﻧﻤﻲ ﮔﻴﺮﻧﺪ ﭘﺲ ﺑﺎﻳﺪ ﺑﺮاي اﻳـﻦ ﻋـﺪد ﻗﺎﻟـﺐ و ﻓﺮﻣﺘـﻲ‬ ‫ﺗﻌﻴﻴﻦ آﺮد. ﭘﺲ از ﺗﺎﺑﻊ )(‪ Format‬ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺘﻔﺎدﻩ ﻣﻲ آﻨﻴﻢ:‬ ‫))”####.##“ ,4*)1(‪Console.WriteLine(Format(Math.Atan‬‬ ‫اﻳﻦ دﺳﺘﻮر ﻧﺘﻴﺠﻪ ﺧﺮوﺟﻲ را ﺑﻪ ﺷﻜﻞ 6141.3 ﻧﻤﺎﻳﺶ ﺧﻮاهﺪ داد.‬ ‫ﻣﺜﺎل دﻳﮕﺮ: ﻓﺮض آﻨﻴﻢ آﻪ ﺷﻤﺎ ﺑﻪ ﻋﻨﻮان ﻳـﻚ ﺣـﺴﺎﺑﺪار در ﻳـﻚ ﺑﺎﻧـﻚ ﻣـﺸﻐﻮل ﺑـﻪ آـﺎر هـﺴﺘﻴﺪ و‬ ‫اﺣﺘﻴﺎج دارﻳﺪ ﺗﺎ در ﻧﺘﻴﺠﻪ ﺣﺴﺎب، ﻳﻚ ﻋﻼﻣﺖ ﺧﺎص ﻣﺜﻼ دﻻر )$( ﻳﺎ رﻳﺎل ﻇﺎهﺮ ﺷﻮد.‬ ‫ﻓﺮض آﻨﻴﺪ آﻪ ﻋﺪد 102543233.454,31 را در ﻧﺘﻴﺠﻪ ي ﻳﻚ ﺣﺴﺎب ﺑﻪ دﺳﺖ ﻣﻲ ﺁورﻳﺪ.‬ ‫ﻣﻲ ﺧﻮاهﻴﻢ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ ،Format‬ﻋﻼﻣﺖ )$( در اﺑﺘﺪاي ﻧﺘﻴﺠﻪ ﻇﺎهﺮ و هﻤﭽﻨـﻴﻦ ﻣﻴـﺰان‬ ‫ﺧﺮدﻩ ي ﭘﻮل ﺑﻪ دﺳﺖ ﺁﻣﺪﻩ ﻓﻘﻂ ﺗﺎ دو رﻗﻢ ﺣﺴﺎب ﺷﻮد. ﭘﺲ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ:‬ ‫102543233.45431= ‪amount‬‬ ‫))”##.###,###$“,‪Console.WriteLine(Format(amount‬‬ ‫ﻧﺘﻴﺠﻪ ﺧﺮوﺟﻲ ﺑﻪ ﺻﻮرت زﻳﺮ ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ:‬ ‫33.454,31$‬ ‫ﺁرﮔﻮﻣﺎن هﺎي ‪ firstdayofweek‬و ‪ ،firstweekofyear‬ﺗﻨﻬﺎ در ﻗﺎﻟﺐ دهﻲ ﺑـﻪ ﻣﻘـﺎدﻳﺮي از ﻧـﻮع‬ ‫ﺗﺎرﻳﺦ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،firstdayofweek‬ﻧﺎم اوﻟﻴﻦ روز هﻔﺘﻪ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ و ﻣﻲ ﺗﻮاﻧﺪ ﻳﻜـﻲ از ﻣﻘـﺎدﻳﺮ‬ ‫زﻳﺮ را ﺑﭙﺬﻳﺮد:‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٩٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ firstdayofweek‬در ﺗﺎﺑﻊ )(‪Format‬‬ ‫ﺗﻮﺿﻴﺤﺎت‬ ‫ﻣﻘﺪار‬ ‫ﻣﻄﺎﺑﻖ ﺑﺎ ﺗﻨﻈﻴﻤﺎت ﺳﻴﺴﺘﻢ‬ ‫0 ﻳﺎ ‪System‬‬ ‫ﻳﻜﺸﻨﺒﻪ )ﻣﻘﺪار ﭘﻴﺶ ﻓﺮض(‬ ‫1 ﻳﺎ ‪Sunday‬‬ ‫دوﺷﻨﺒﻪ‬ ‫2 ﻳﺎ ‪Monday‬‬ ‫ﺳﻪ ﺷﻨﺒﻪ‬ ‫3 ﻳﺎ ‪Tuesday‬‬ ‫ﭼﻬﺎرﺷﻨﺒﻪ‬ ‫4 ﻳﺎ ‪Wednesday‬‬ ‫ﭘﻨﺞ ﺷﻨﺒﻪ‬ ‫5 ﻳﺎ ‪Thursday‬‬ ‫ﺟﻤﻌﻪ‬ ‫6 ﻳﺎ ‪Friday‬‬ ‫ﺷﻨﺒﻪ‬ ‫7 ﻳﺎ ‪Saturday‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،firstweekofyear‬اوﻟﻴﻦ هﻔﺘﻪ از ﺳﺎل را ﻣـﺸﺨﺺ ﻣـﻲ آﻨـﺪ و ﻳﻜـﻲ از ﻣﻘـﺎدﻳﺮ زﻳـﺮ را‬ ‫ﻣﻲ ﭘﺬﻳﺮد:‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ firstweekofyear‬در ﺗﺎﺑﻊ )(‪Format‬‬ ‫ﺗﻮﺿﻴﺤﺎت‬ ‫ﻣﻘﺪار‬ ‫ﻣﻄﺎﺑﻖ ﺑﺎ ﺗﻨﻈﻴﻤﺎت ﺳﻴﺴﺘﻢ.‬ ‫0 ﻳﺎ ‪System‬‬ ‫ﺳﺎل ﺑﺎ هﻔﺘﻪ اول ﻣﺎﻩ ژاﻧﻮﻳﻪ ﺁﻏﺎز ﻣﻲ ﺷﻮد.‬ ‫1 ﻳﺎ 1‪FirstJan‬‬ ‫ﺳﺎل ﺑﺎ هﻔﺘﻪ اي ﺁﻏﺎز ﻣﻲ ﺷـﻮد آـﻪ ﺣـﺪاﻗﻞ ٤‬ ‫2 ﻳﺎ ‪FirstFourDays‬‬ ‫روز ﺁن در ﺳﺎل ﺟﺪﻳﺪ ﺑﺎﺷﺪ.‬ ‫ﺳﺎل ﺑﺎ هﻔﺘﻪ اي ﺁﻏﺎز ﻣـﻲ ﺷـﻮد آـﻪ آـﺎﻣﻼ در‬ ‫3 ﻳﺎ ‪FirstFullWeek‬‬ ‫ﺳﺎل ﺟﺪﻳﺪ ﺑﺎﺷﺪ.‬ ‫ﻗﺎﻟﺐ هـﺎي ﻣﺨﺘﻠﻔـﻲ ﺑـﺮاي ﻧﻤـﺎﻳﺶ ﻣﻘـﺎدﻳﺮ ﻋـﺪدي، رﺷـﺘﻪ اي، ﺗـﺎرﻳﺦ و زﻣـﺎن وﺟـﻮد دارد آـﻪ در‬ ‫ﻟﻴﺴﺖ زﻳﺮ ﺗﻤﺎﻣﻲ ﺁﻧﻬﺎ را ﻣﻲ ﺑﻴﻨﻴﺪ:‬ ‫آﺎراآﺘﺮهﺎﻳﻲ آﻪ ﻣﻲ ﺗﻮان ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ ﺗﺎرﻳﺦ و زﻣﺎن ﺑﻪ آﺎر ﺑﺮد:‬ ‫/ : اﻳﻦ آﺎراآﺘﺮ، ﺟﻬﺖ ﺟﺪا آﺮدن ﺳﺎل، ﻣﺎﻩ و روز از ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ ﺑﻪ آـﺎر ﻣـﻲ رود. اﻟﺒﺘـﻪ‬ ‫در ﺑﻌﻀﻲ ﻣﻜﺎن هﺎ ﻣﻤﻜﻦ اﺳﺖ از آﺎراآﺘﺮهﺎي دﻳﮕﺮي ﺟﻬﺖ اﻳﻦ آﺎر اﺳﺘﻔﺎدﻩ ﺷﻮد.‬ ‫: : اﻳﻦ آﺎراآﺘﺮ، ﺟﻬﺖ ﺟﺪاآﺮدن ﺳﺎﻋﺖ، دﻗﻴﻘﻪ و ﺛﺎﻧﻴﻪ از ﻳﻚ ﻣﻘﺪار از ﻧﻮع زﻣﺎن ﺑـﻪ آـﺎر ﻣـﻲ رود.‬ ‫اﻟﺒﺘﻪ در ﺑﻌﻀﻲ از ﻣﻜﺎن هﺎ ﻣﻤﻜﻦ اﺳﺖ از آﺎراآﺘﺮهﺎي دﻳﮕﺮي ﺟﻬﺖ اﻳﻦ آﺎر اﺳﺘﻔﺎدﻩ ﺷﻮد.‬ ‫‪ : d‬اﻳﻦ آﺎراآﺘﺮ، روز ﻳﻚ ﻣﺎﻩ را ﺑﻪ وﺳﻴﻠﻪ ﻳﻚ ﻋﺪد ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ. اﻳﻦ ﻋﺪد ﻣﻘﺪاري ﺑـﻴﻦ 1 ﺗـﺎ‬ ‫13 اﺳﺖ.‬ ‫‪: dd‬اﻳﻦ آﺎراآﺘﺮ، هﻤﺎﻧﻨﺪ آﺎراآﺘﺮ ‪ d‬رﻓﺘﺎر ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ اﻳﻦ ﺗﺎﺑﻊ، ﻗﺒـﻞ از ارﻗـﺎم ﻳـﻚ ﺗـﺎ‬ ‫ﻧﻪ، ﺻﻔﺮ )0( ﻣﻲ ﮔﺬارد. 10،20،30 و… اﻣﺎ آﺎراآﺘﺮ ‪ ،d‬اﻋﺪاد ﻳﻚ ﺗﺎ ﻧﻪ را ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮل ﻧﺸﺎن‬ ‫ﻣﻲ دهﺪ ﻳﻌﻨﻲ 1،2، 3 و…‬ ‫‪ : ddd‬اﻳﻦ آﺎراآﺘﺮ، ﻧﺎم اﺧﺘﺼﺎري ﻳﻚ روز را ﻧﺸﺎن ﻣﻲ دهﺪ. ﻣﺜﻼ: )‪(Sun-Sat‬‬ ‫‪ : dddd‬اﻳﻦ آﺎراآﺘﺮ، ﻧﺎم آﺎﻣﻞ روز را ﻧﺸﺎن ﻣﻲ دهﺪ. ﻣﺜﻼ: )‪(Sunday-Saturday‬‬ ‫‪ : w‬اﻳــﻦ آــﺎراآﺘﺮ، ﻋــﺪدي را آــﻪ ﻧﻤﺎﻳــﺎﻧﮕﺮ روز هﻔﺘــﻪ اﺳــﺖ ﻧــﺸﺎن ﻣــﻲ دهــﺪ. ﻣــﺜﻼ ﻋــﺪد 1‬ ‫ﺑﺮاي ‪ Sunday‬و 7 ﺑﺮاي ‪Saturday‬‬ ‫‪ : ww‬اﻳﻦ آﺎراآﺘﺮ، ﻋﺪدي را آﻪ ﻧﻤﺎﻳﺎﻧﮕﺮ هﻔﺘﻪ ﺳﺎل اﺳﺖ ﻧﻤﺎﻳﺶ ﻣﻲ دهـﺪ. اﻳـﻦ ﻋـﺪد ﺑـﻴﻦ 1‬ ‫ﺗﺎ 45 اﺳﺖ.‬ ‫‪ : M‬اﻳﻦ آﺎراآﺘﺮ، ﻋﺪدي را آﻪ ﻧﻤﺎﻳﺎﻧﮕﺮ ﻣﺎﻩ ﺳﺎل اﺳﺖ ﻧﺸﺎن ﻣﻲ دهـﺪ. اﮔـﺮ ﺑـﺎ آﺎراآﺘﺮهـﺎي ‪h‬‬ ‫ﻳﺎ ‪ hh‬ﺑﻴﺎﻳﺪ، ﺑﻪ ﺟﺎي ﻧﻤﺎﻳﺶ ﻋﺪد ﻣﺎﻩ، دﻗﻴﻘﻪ را ﻧﺸﺎن ﺧﻮاهﺪ داد.‬ ‫‪ : MM‬اﻳﻦ آﺎراآﺘﺮ هﻤﺎﻧﻨﺪ آﺎراآﺘﺮ ‪ M‬رﻓﺘﺎر ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ اﻳـﻦ ﺗـﺎﺑﻊ ﻗﺒـﻞ از ارﻗـﺎم 0 ﺗـﺎ‬ ‫9، ﺻﻔﺮ )0( ﻣﻲ ﮔﺬارد اﻣﺎ آﺎراآﺘﺮ ‪ ،M‬اﻋﺪاد را ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮل ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫‪ : MMM‬اﻳﻦ آﺎراآﺘﺮ، ﻧﺎم اﺧﺘﺼﺎري ﻳﻚ ﻣﺎﻩ را ﻧﺸﺎن ﻣﻲ دهﺪ. ﻣﺜﻼ: )‪(Jan-Dec‬‬ ‫‪ : MMMM‬اﻳﻦ آﺎراآﺘﺮ، ﻧﺎم آﺎﻣﻞ ﻣﺎﻩ را ﻧﺸﺎن ﻣﻲ دهﺪ. ﻣﺜﻼ: )‪(January-December‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٠٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫‪: q‬اﻳﻦ آﺎراآﺘﺮ، ﻳﻚ ﭼﻬﺎرم ﻳﻚ ﺳﺎل را ﺑﺎ اﻋﺪادي ﺑﻴﻦ 1 ﺗﺎ 4 ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ. )ﻣﺘﻨﺎﻇﺮ ﻓﺼﻞ(‬ ‫‪ : y‬اﻳﻦ آﺎراآﺘﺮ، ﻋﺪدي را آﻪ ﻧﻤﺎﻳﺎﻧﮕﺮ روز ﺳﺎل اﺳﺖ ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ. )1 ﺗﺎ 663(‬ ‫‪ : yy‬اﻳﻦ آﺎراآﺘﺮ، ﻋﺪدي دو رﻗﻤﻲ را ﻧﺸﺎن ﻣﻲ دهﺪ آﻪ ﻧﻤﺎﻳﺎﻧﮕﺮ ﺳﺎل اﺳﺖ. )00 ﺗﺎ 99(‬ ‫‪ : yyyy‬اﻳﻦ آﺎراآﺘﺮ، ﻋﺪدي 4 رﻗﻤﻲ را ﻧﻤﺎﻳﺶ ﻣﻲ دهـﺪ آـﻪ ﻧﻤﺎﻳـﺎﻧﮕﺮ ﺳـﺎل اﺳـﺖ. )0000 ﺗـﺎ‬ ‫9999(‬ ‫‪ : h‬اﻳﻦ آﺎراآﺘﺮ، ﻋﺪدي را آﻪ ﻧﻤﺎﻳﺎﻧﮕﺮ ﺳﺎﻋﺖ اﺳﺖ ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ. )0 ﺗﺎ 21(‬ ‫‪ : hh‬اﻳﻦ آﺎراآﺘﺮ هﻤﺎﻧﻨﺪ آﺎراآﺘﺮ ‪ h‬رﻓﺘﺎر ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ اﻳﻦ ﺗﺎﺑﻊ ﻗﺒﻞ از ارﻗﺎم 0 ﺗﺎ 21،‬ ‫ﺻﻔﺮ )0( ﻣﻲ ﮔﺬارد اﻣﺎ آﺎراآﺘﺮ ‪ ،h‬اﻋﺪاد را ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮل ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫‪ : H‬اﻳﻦ آﺎراآﺘﺮ، ﺷﻜﻞ آﺎﻣﻠﺘﺮ آﺎراآﺘﺮ ‪ h‬اﺳﺖ و ﺳﺎﻋﺖ را ﺑﻪ ﺻﻮرت 0 ﺗﺎ 42 ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔﺮ ﺳﺎﻋﺖ ﻓﻌﻠﻲ ﺳﻴﺴﺘﻢ 3 ﺑﺎﺷﺪ، 3ﺻﺒﺢ را ﺑﺎ ﻋﺪد 3 و 3 ﺑﻌﺪ از ﻇﻬﺮ را ﺑﺎ ﻋـﺪد‬ ‫51 ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫‪ : HH‬اﻳﻦ آﺎراآﺘﺮ، هﻤﺎﻧﻨﺪ آﺎراآﺘﺮ ‪ H‬رﻓﺘﺎر ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ ﻗﺒـﻞ از ارﻗـﺎم 0 ﺗـﺎ 9، ﺻـﻔﺮ‬ ‫)0( ﻣﻲ ﮔﺬارد. )00 ﺗﺎ 90( وﻟﻲ آﺎراآﺘﺮ ‪ ،H‬ارﻗﺎم 0 ﺗﺎ 9 را ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮل ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫‪:m‬اﻳﻦ آﺎراآﺘﺮ، دﻗﻴﻘﻪ را را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ، ﻣﻨﺘﻬﺎ ﺑﺪون ﮔﺬاﺷﺘﻦ ﻋﺪد ﺻﻔﺮ ﻗﺒـﻞ از ارﻗـﺎم 0 ﺗـﺎ‬ ‫9. ﺑﺎزﻩ ي اﻳﻦ آﺎراآﺘﺮ، ﻋﺪدي ﺑﻴﻦ 0 ﺗﺎ 95 اﺳﺖ.‬ ‫‪ :mm‬هﻤﺎﻧﻨﺪ آﺎراآﺘﺮ ‪ m‬رﻓﺘﺎر آﺮدﻩ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ ﻗﺒﻞ از اﻋﺪاد 0 ﺗﺎ 9، ﺻﻔﺮ )0( ﻣﻲ ﮔﺬارد.‬ ‫‪ :s‬اﻳﻦ آﺎراآﺘﺮ، ﺛﺎﻧﻴﻪ را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ، ﻣﻨﺘﻬﺎ ﺑﺪون ﮔﺬاﺷﺘﻦ ﻋﺪد ﺻـﻔﺮ ﻗﺒـﻞ از ارﻗـﺎم 0 ﺗـﺎ 9.‬ ‫ﺑﺎزﻩ ي اﻳﻦ آﺎراآﺘﺮ ﺑﻴﻦ 0 ﺗﺎ 95 اﺳﺖ.‬ ‫‪ :ss‬هﻤﺎﻧﻨﺪ آﺎراآﺘﺮ ‪ s‬رﻓﺘﺎر آﺮدﻩ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ ﻗﺒﻞ از اﻋﺪاد 0 ﺗﺎ 9، ﺻﻔﺮ )0( ﻣﻲ ﮔﺬارد.‬ ‫‪ : AM/PM‬ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ هﻢ اآﻨﻮن ﻗﺒﻞ از ﻇﻬﺮ اﺳﺖ )‪ (AM‬ﻳﺎ ﺑﻌﺪ از ﻇﻬﺮ )‪(PM‬‬ ‫‪ :am/pm‬هﻤﺎن آﺎراآﺘﺮ ‪ AM/PM‬اﺳﺖ، ﻓﻘﻂ ﻗﺒﻞ ﻳﺎ ﺑﻌﺪ ﺑﻮدن ﻇﻬﺮ را ﺑﺎ ﺣﺮوف آﻮﭼـﻚ ﻧﻤـﺎﻳﺶ‬ ‫ﻣﻲ دهﺪ. )‪(am/pm‬‬ ‫‪ : A/P‬ﻗﺒﻞ ﻳﺎ ﺑﻌﺪ ﺑﻮدن ﻇﻬﺮ را ﺑﺎ ﺣﺮوف اﺧﺘﺼﺎري ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ. ) ‪ A‬ﻳﺎ ‪(P‬‬ ‫‪ : a/p‬هﻤﺎن آﺎراآﺘﺮ ‪ A/P‬اﺳﺖ، ﻓﻘﻂ ﻗﺒﻞ ﻳﺎ ﺑﻌـﺪ ﺑـﻮدن ﻇﻬـﺮ را ﺑـﺎ ﺣـﺮوف آﻮﭼـﻚ ﻧﻤـﺎﻳﺶ ﻣـﻲ‬ ‫دهﺪ.)‪ a‬ﻳﺎ ‪(p‬‬ ‫‪ : AMPM‬اﻳﻦ آﺎراآﺘﺮ ﻧﻴﺰ ﻗﺒﻞ ﻳﺎ ﺑﻌﺪ ﺑﻮدن ﻇﻬﺮ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ اﻣـﺎ ﺑـﻪ ﺟـﺎي اﻳـﻦ آـﺎراآﺘﺮ،‬ ‫آﺎراآﺘﺮي آﻪ ﺑﻪ وﺳﻴﻠﻪ ﺳﻴﺴﺘﻢ ﺗﻌﻴﻴﻦ ﺷﺪﻩ ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ. ﺑﻪ ﻋﻨﻮان ﻣﺜـﺎل در وﻳﻨـﺪوز هـﺎي‬ ‫ﻓﺎرﺳﻲ ﺑﺎ آﻠﻤﺎت “ﺻﺒﺢ” و “ﻋﺼﺮ” ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﺑــﺮاي ﺗﻐﻴﻴــﺮ ﻧﺤــﻮﻩ ﻧﻤــﺎﻳﺶ، ﺑــﻪ ﺳــﺮﺑﺮگ ‪ Regional Options‬از ﻗــﺴﻤﺖ ‪Regional and‬‬ ‫‪ Language Options‬در ‪ Control Panel‬ﻣﺮاﺟﻌﻪ آﻨﻴﺪ.‬ ‫آﺎراآﺘﺮهﺎﻳﻲ آﻪ ﻣﻲ ﺗﻮان ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ ﻣﻘﺎدﻳﺮ ﻋﺪدي ﺑﻪ آﺎر ﺑﺮد، ٦١ آـﺎراآﺘﺮ هـﺴﺘﻨﺪ آـﻪ‬ ‫ﻧﺤﻮﻩ ي آﺎر ﺑﺎ ﺁﻧﻬﺎ ﺑﺮ ﻋﻬﺪﻩ ي ﺧﻮاﻧﻨﺪﮔﺎن ﻋﺰﻳﺰ اﺳﺖ.‬ ‫] ‪FormatCurrency(expression [,numDigitsAfterDecimal‬‬ ‫)] ‪[,includeLeadingDigit ][,useParensForNegativeNumbers ][,groupDigits‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻣﻘﺪار ﻋﺪدي را ﺑﻪ ﺷﻜﻞ ﻳﻚ ﻣﻘﺪار ارزي )‪ (Currency‬ﻗﺎﻟﺐ ﺑﻨـﺪي ﺷـﺪﻩ هﻤـﺮاﻩ ﺑـﺎ‬ ‫ﻧﻤﺎدي آﻪ در ﺳﺮﺑﺮگ ‪ Regional Options‬از ﻗﺴﻤﺖ ‪Regional and Language Options‬‬ ‫از ‪ Control Panel‬ﻣﺸﺨﺺ ﺷﺪﻩ اﺳﺖ، ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺑ ـﻪ ﻋﻨ ـﻮان ﻣﺜ ـﺎل در وﻳﻨ ـﺪوزهﺎي ﻓﺎرﺳ ـﻲ، ﻧﻤ ـﺎد ﻣﻘ ـﺎدﻳﺮ ارزي ﺑ ـﺎ آﻠﻤ ـﻪ “رﻳ ـﺎل” و در وﻳﻨ ـﺪوزهﺎي‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫اﻧﮕﻠﻴﺴﻲ ﺑﺎ آﺎراآﺘﺮ ”$“، ﻣﺸﺨﺺ ﻣﻲ ﺷﻮد.‬ ‫ﺑﺮاي ﺗﻐﻴﻴﺮ ﻧﺤﻮﻩ ﻧﻤﺎﻳﺶ اﻳﻦ ﻣﻘﺎدﻳﺮ، ﺑﻪ ﻗﺴﻤﺖ ﮔﻔﺘﻪ ﺷﺪﻩ در ﺑﺎﻻ ﻣﺮاﺟﻌﻪ آﻨﻴﺪ.‬ ‫در اﻳﻦ ﺗﺎﺑﻊ، ﺗﻤﺎﻣﻲ ﺁرﮔﻮﻣﺎن هﺎ ﺑﻪ ﺟﺰ اوﻟﻴﻦ ﺁرﮔﻮﻣﺎن، اﺧﺘﻴﺎري هﺴﺘﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻣﻘﺪاري ﻋﺪدي اﺳﺖ آﻪ ﻗﺼﺪ ﺑﺮﮔﺸﺖ ﺁن ﺑﺎ ﻓﺮﻣﺖ ‪ Currency‬را دارﻳﻢ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،numDigitsAfterDecimal‬ﻣﻘﺪاري ﻋﺪدي اﺳﺖ آﻪ ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ ﭼﻨﺪ ﻋـﺪد در‬ ‫ﺳﻤﺖ راﺳـﺖ ﺑﻌـﺪ از اﻋـﺸﺎر ﺑﺎﻳـﺪ ﻗـﺮار ﺑﮕﻴﺮﻧـﺪ. ﻣﻘـﺪار ﭘـﻴﺶ ﻓـﺮض، 1- اﺳـﺖ ﻳﻌﻨـﻲ ﺗﻨﻈﻴﻤـﺎت‬ ‫‪ Regional and Language Options‬را ﺑﻪ آﺎر ﻣﻲ ﺑﺮد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،includeLeadingDigit‬ﻳﻚ ﻣﻘﺪار ﺛﺎﺑـﺖ ‪ Tristate‬اﺳـﺖ. )ﺛﺎﺑـﺖ ‪ ،Tristate‬ﻣﻘـﺪاري‬ ‫اﺳـﺖ آـﻪ ﻣـﻲ ﺗﻮاﻧـﺪ ‪ False ،True‬ﻳـﺎ ‪ UseDefault‬ﺑﺎﺷـﺪ( و ﻣـﺸﺨﺺ ﻣـﻲ آﻨـﺪ آـﻪ ﺁﻳـﺎ اﮔـﺮ‬ ‫ـ ـ ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫ﻣﻘﺪاري اﻋﺸﺎري آﻤﺘﺮ از 1 ﺑﻮد، در ﺳﻤﺖ ﭼﭗ اﻋﺸﺎر، ﻋﺪد ﺻﻔﺮ ﻗﺮار ﮔﻴﺮد ﻳﺎ ﺧﻴﺮ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻋﺪد هﻔﺖ دهﻢ آﻪ ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ ﺷﻜﻞ ”7.0“ و ﻳﺎ ”7.“ ﻧﻤﺎﻳﺶ دادﻩ ﺷﻮد.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫١٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﺁرﮔﻮﻣــﺎن ‪ ،useParensForNegativeNumbers‬ﻧﻴــﺰ ﻳــﻚ ﻣﻘــﺪار ﺛﺎﺑــﺖ ‪ Tristate‬اﺳــﺖ آــﻪ‬ ‫ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ ﺁﻳﺎ اﻋﺪاد ﻣﺜﺒﺖ را ﺑﺎ دو ﭘﺮاﻧﺘﺰ در دو ﻃﺮف ﺁﻧﻬﺎ ﺑﺮﮔﺸﺖ دهﺪ ﻳﺎ ﺧﻴﺮ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ groupDigits‬هﻢ ﻳﻚ ﻣﻘﺪار ﺛﺎﺑﺖ ‪ Tristate‬اﺳﺖ و ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ ﺁﻳـﺎ اﻋـﺪاد ﺑـﻴﺶ‬ ‫از 5 رﻗﻤﻲ ﺑﺎ آﺎراآﺘﺮي آﻪ در ﻗـﺴﻤﺖ ‪ Regional and Language Options‬ﻣـﺸﺨﺺ ﺷـﺪﻩ‬ ‫از ﻳﻜﺪﻳﮕﺮ ﺟﺪا ﺷﻮﻧﺪ ﻳﺎ ﺧﻴﺮ. ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل در ﺻﻮرت ‪ True‬ﺑﻮدن اﻳـﻦ ﺁرﮔﻮﻣـﺎن، ﻋـﺪد 654,432‬ ‫ﺑﻪ ﻃﺮﻳﻘﻲ آﻪ ﻣﺸﺎهﺪﻩ ﻣﻲ آﻨﻴﺪ ﺑﺎ آﺎراآﺘﺮ ),( از ﻳﻜﺪﻳﮕﺮ ﺟـﺪا ﺷـﺪﻩ و اﻋـﺪاد از ﺳـﻤﺖ راﺳـﺖ،‬ ‫ﺳﻪ ﺗﺎ ﺳﻪ ﺗﺎ ﺟﺪا ﻣﻲ ﺷﻮﻧﺪ. در ﺻﻮرت ‪ False‬ﺑﻮدن اﻳﻦ ﺁرﮔﻮﻣﺎن، اﻋﺪاد ﭘﺸﺖ ﺳﺮ هـﻢ و ﺑـﺪون‬ ‫آﺎراآﺘﺮ ﺟﺪاآﻨﻨﺪﻩ ﻇﺎهﺮ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫)] ‪FormatDateTime(date [,namedFormat‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ )‪ (Date‬ﻳﺎ زﻣﺎن )‪ (Time‬را ﻗﺎﻟﺐ ﺑﻨﺪي ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،date‬ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ ﻳﺎ زﻣﺎن اﺳﺖ آﻪ ﺑﺎﻳﺪ ﻗﺎﻟﺐ ﺑﻨﺪي ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،namedFormat‬ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ ﭼﻪ ﻧﻮع ﻗﺎﻟﺐ ﺑﻨﺪي ﺑﺎﻳﺪ ﺑﺮاي ﺗﺎرﻳﺦ ﻳـﺎ‬ ‫زﻣﺎن ﺑﻪ آﺎر رود.‬ ‫اﻳﻦ ﺁرﮔﻮﻣﺎن ﻣﻲ ﺗﻮاﻧﺪ ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ زﻳﺮ را ﺑﭙﺬﻳﺮد:‬ ‫‪ :GeneralDate‬اﮔﺮ در ﺁرﮔﻮﻣﺎن ‪ ،date‬ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ ﺁﻣﺪﻩ ﺑﺎﺷﺪ، ﺗﺎرﻳﺦ ﺑﻪ ﺷﻜﻞ آﻮﺗﺎﻩ‬ ‫ﻣﺜﻼ ”4002/20/41“ﻧﻤﺎﻳﺶ دادﻩ ﺧﻮاهﺪ ﺷﺪ و اﮔﺮ ﻣﻘﺪار از ﻧﻮع زﻣـﺎن ﺑﺎﺷـﺪ، زﻣـﺎن ﺑـﻪ ﺷـﻜﻞ‬ ‫آﺎﻣﻞ ﻣﺜﻼ “ﻋﺼﺮ 55:74:60“ ﻧﻤﺎﻳﺶ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﺗﻮﺟﻪ: اﮔﺮ هﺮ دو ﻣﻘﺪار ﺗﺎرﻳﺦ و زﻣﺎن ﺑﻪ آﺎر روﻧﺪ، ﭘﺸﺖ ﺳﺮ هﻢ ﻧﻤﺎﻳﺶ دادﻩ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫‪ :LongDate‬اﻳﻦ ﻣﻘﺪار ﺛﺎﺑﺖ، ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗـﺎرﻳﺦ را ﺑـﻪ ﺻـﻮرت ﻃـﻮﻻﻧﻲ ﻧﻤـﺎﻳﺶ و ﺑﺮﮔـﺸﺖ‬ ‫ﻣﻲ دهﺪ. ﻣﺜﻼ: “ﺷﻨﺒﻪ, ٤١ ﺁﺑﺎن, ٢٨٣١ ”‬ ‫‪ :ShortDate‬اﻳﻦ ﻣﻘﺪار ﺛﺎﺑﺖ، ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ را ﺑﻪ ﺻﻮرت آﻮﺗﺎﻩ ﻧﻤﺎﻳﺶ و ﺑﺮﮔـﺸﺖ ﻣـﻲ‬ ‫دهﺪ. ﻣﺜﻼ: “٤١/٢٠/٤٠٠٢”‬ ‫‪ :LongTime‬اﻳﻦ ﻣﻘﺪار ﺛﺎﺑﺖ، ﻳﻚ ﻣﻘﺪار از ﻧﻮع زﻣﺎن را ﺑـﻪ ﺻـﻮرت ﻃـﻮﻻﻧﻲ ﻧﻤـﺎﻳﺶ ﻣـﻲ دهـﺪ.‬ ‫ﻣﺜﻼ: “٤٣:٨٥:٦٠ ﻋﺼﺮ”‬ ‫‪ :ShortTime‬اﻳﻦ ﻣﻘﺪار ﺛﺎﺑﺖ، ﻳﻚ ﻣﻘﺪار از ﻧﻮع زﻣﺎن را ﺑﻪ ﺻﻮرت آﻮﺗﺎﻩ ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﻣﺜﻼ: “٣٢:٩١”‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: ﺗﻤـﺎﻣﻲ ﻣﻘـﺎدﻳﺮ ﺛﺎﺑـﺖ ﺑـﺎﻻ، ﺑـﺮ اﺳـﺎس ﺗﻨﻈﻴﻤـﺎﺗﻲ آـﻪ در ﻗـﺴﻤﺖ ‪Regional and‬‬ ‫‪ Language Options‬از ‪ Control Panel‬ﺻﻮرت ﮔﺮﻓﺘﻪ اﺳﺖ ﻋﻤﻞ ﻣﻲ آﻨﻨﺪ.‬ ‫] ‪FormatNumber(expression [,numDigitsAfterDecimal‬‬ ‫)] ‪[,includeLeadingDigit ][,useParensForNegativeNumbers ][,groupDigits‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻣﻘﺪار ﻋﺪدي را ﺑﺎ ﻗﺎﻟﺐ ﺑﻨﺪي دﻳﮕﺮي ﺑﻪ ﺻﻮرت ﻋﺪدي ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺗﻤﺎﻣﻲ ﺁرﮔﻮﻣﺎن هﺎي اﻳﻦ ﺗﺎﺑﻊ در ﺗﻮﺿﻴﺤﺎت ﺗﺎﺑﻊ )(‪ FormatCurrency‬ﺑﻴﺎن ﺷﺪﻧﺪ.‬ ‫] ‪FormatPercent(expression [,numDigitsAfterDecimal‬‬ ‫)] ‪[,includeLeadingDigit ][,useParensForNegativeNumbers ][,groupDigits‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻋﺪد را ﺑﺮ ﺣﺴﺐ درﺻﺪ ﺑﺮﮔﺸﺖ ﻣـﻲ دهـﺪ ﻳﻌﻨـﻲ ﻋـﺪد را در ٠٠١ ﺿـﺮب آـﺮدﻩ و ﺑـﺎ‬ ‫ﻧﻤﺎد درﺻﺪ )%( و ﺑﺎ ﻗﺎﻟﺒﻲ آﻪ ﻣﺸﺨﺺ ﺷﺪﻩ اﺳﺖ ﺑﺮﮔﺸﺖ و ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﺗﻤﺎﻣﻲ ﺁرﮔﻮﻣﺎن هﺎي اﻳﻦ ﺗﺎﺑﻊ در ﺗﻮﺿﻴﺤﺎت ﺗﺎﺑﻊ )(‪ FormatCurrency‬ﺑﻴﺎن ﺷﺪﻧﺪ.‬ ‫)‪LSet(string,len) , RSet(string,len‬‬ ‫اﻳﻦ ﺗﻮاﺑﻊ، ﺑـﻪ ﺗﻌـﺪادي آـﻪ ﻣـﺸﺨﺺ ﻣـﻲ ﺷـﻮد، در ﺳـﻤﺖ ﭼـﭗ )‪ (Lset‬ﻳـﺎ راﺳـﺖ )‪ (Rset‬ﻳـﻚ‬ ‫ﻋﺒﺎرت، ﻓﻀﺎي ﺧﺎﻟﻲ ﻗﺮار ﻣﻲ دهﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ string‬آﻪ ﻣﻲ ﺗﻮاﻧﺪ از هﺮ ﻧﻮع ﻣﻘﺪاري ﺑﺎﺷﺪ، رﺷﺘﻪ اي را ﻣﺸﺨﺺ ﻣﻲ آﻨـﺪ آـﻪ ﺑﺎﻳـﺪ‬ ‫در ﺳﻤﺖ ﭼﭗ ﻳﺎ راﺳﺖ ﺁن، ﻓﻀﺎي ﺧﺎﻟﻲ اﺿﺎﻓﻪ ﺷﻮد.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٢٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﺁرﮔﻮﻣﺎن ‪ len‬ﻧﻴﺰ ﻣﻘﺪاري ﻋﺪدي اﺳﺖ آﻪ ﺗﻌﺪاد ﻓﻀﺎي ﺧﺎﻟﻲ را آﻪ ﺑﺎﻳﺪ اﻳﺠﺎد ﺷﻮد ﻣﺸﺨﺺ ﻣﻲ‬ ‫آﻨﺪ.‬ ‫ﻣﺜﺎل هﺎي زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)”]“ & )02,”‪Console.WriteLine(“[“ & RSet(“Behrouz‬‬ ‫)”]“ & )02,”‪Console.WriteLine(“[“ & LSet(“Rad‬‬ ‫))01,65.43(‪Console.WriteLine(RSet‬‬ ‫))01,99.6534(‪Console.WriteLine(RSet‬‬ ‫))01,10.4(‪Console.WriteLine(RSet‬‬ ‫ﺧﺮوﺟﻲ ﭘﺲ از اﺟﺮا ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺧﻮاهﺪ ﺷﺪ:‬ ‫[‬ ‫]‪Behrouz‬‬ ‫‪[Rad‬‬ ‫]‬ ‫65.43‬ ‫99.6534‬ ‫10.4‬ ‫)‪Val(string) , Str(number‬‬ ‫ﺗﺎﺑﻊ )(‪ ،Val‬ﻳـﻚ ﻣﻘـﺪار رﺷـﺘﻪ اي را ﺑـﻪ ﻋﻨـﻮان ورودي درﻳﺎﻓـﺖ آـﺮدﻩ و ﺁن را ﺑـﻪ ﺻـﻮرت ﻣﻘـﺪاري‬ ‫ﻋﺪدي ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ Str‬دﻗﻴﻘﺎ ﻋﻜﺲ ﺗـﺎﺑﻊ )(‪ Val‬رﻓﺘـﺎر آـﺮدﻩ و ﻳـﻚ ﻣﻘـﺪار ﻋـﺪدي را درﻳﺎﻓـﺖ آـﺮدﻩ و ﺁن را ﺑـﻪ‬ ‫ﺻﻮرت ﻣﻘﺪاري ﻋﺪدي ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﻣﻜﺎﻧﻴﺰم آﺎر ﺗﺎﺑﻊ )(‪ Val‬ﺑﻪ اﻳﻦ ﺷﻜﻞ اﺳﺖ آﻪ از اﺑﺘﺪاي رﺷﺘﻪ ورودي ﺷﺮوع ﺑﻪ ﺧﻮاﻧـﺪن ﺁن ﻣـﻲ‬ ‫آﻨﺪ و زﻣﺎﻧﻲ آﻪ ﺑﻪ آﺎراآﺘﺮي ﻏﻴـﺮ ﻋـﺪدي رﺳـﻴﺪ ﺟـﺴﺘﺠﻮ ﻣﺘﻮﻗـﻒ و ﻧﺘﻴﺠـﻪ ﺑﺮﮔـﺸﺖ دادﻩ ﻣـﻲ‬ ‫ﺷﻮد.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫” 50.6:81“= ‪Dim a As String‬‬ ‫))‪Console.WriteLine(Val(a‬‬ ‫آﺎراآﺘﺮي ﻏﻴﺮ ﻋﺪدي اﺳﺖ.‬ ‫آﺎراآﺘﺮ ”:“‬ ‫ﻧﺘﻴﺠﻪ ي ﺧﺮوﺟﻲ، ﻋﺪد 81 ﺧﻮاهﺪ ﺑﻮد زﻳﺮا‬ ‫ﻣﺜﺎﻟﻲ ﺑﺮاي ﺗﺎﺑﻊ )(‪:Str‬‬ ‫81 = ‪Dim a As Integer‬‬ ‫))‪Console.WriteLine(Str(a‬‬ ‫ﻧﺘﻴﺠﻪ ﺧﺮوﺟﻲ، رﺷﺘﻪ ”81“ ﺧﻮاهﺪ ﺑﻮد.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٣٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)‪:(Math‬‬ ‫ﺗﻮاﺑﻊ رﻳﺎﺿﻲ‬ ‫در ‪ VB.NET‬ﺗﻤﺎﻣﻲ ﺗﻮاﺑﻊ رﻳﺎﺿﻲ 0.6.‪ VB‬ﺑﻪ ﻋﻨﻮان ﻣﺘﺪهﺎﻳﻲ در آـﻼس ‪ Math‬ﻗـﺮار دادﻩ ﺷـﺪﻩ‬ ‫اﻧﺪ. ﭘﺲ در اﻳﻦ ﺑﺨﺶ ﺁﻧﻬﺎ را ﺑﺎ ﻧﺎم ﻣﺘﺪ ﺻﺪا ﻣﻲ زﻧﻴﻢ.‬ ‫ﺑﺮاي اﺳﺘﻔﺎدﻩ از ﻣﺘﺪهﺎي رﻳﺎﺿﻲ در ‪ VB.NET‬ﺑﺎﻳﺪ آﻼس ‪ Math‬را ﺑﻪ ﺑﺮﻧﺎﻣـﻪ ي ﺧـﻮد اﺿـﺎﻓﻪ ﻳـﺎ‬ ‫ﻗﺒﻞ از اﺳـﺘﻔﺎدﻩ از اﻳـﻦ ﻣﺘـﺪهﺎ، آﻠﻤـﻪ ‪ Math‬را ﻗﺒـﻞ از ﻧـﺎم ﻣﺘـﺪ ذآـﺮ آﻨﻴـﺪ ﻣﺜـﻞ: )‪،Math.Abs‬‬ ‫‪(Math.Cos‬‬ ‫)‪Abs(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ، ﻗﺪر ﻣﻄﻠﻖ ﻳﻚ ﻋﺒﺎرت ﻋﺪدي را ﻣﺤﺎﺳﺒﻪ ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻋﺪدي اﺳﺖ آﻪ ﺑﺎﻳﺪ ﻗﺪر ﻣﻄﻠـﻖ ﺁن ﻣﺤﺎﺳـﺒﻪ ﮔـﺮدد. اﮔـﺮ ‪expression‬‬ ‫ﺑﺰرﮔﺘﺮ ﻳﺎ ﻣﺴﺎوي ﺻﻔﺮ ﺑﺎﺷﺪ، ﻧﺘﻴﺠﻪ ي ﻣﺘﺪ هﻤﺎن ﻋﺒﺎرت ‪ expression‬ﺧﻮاهﺪ ﺑﻮد وﮔﺮﻧﻪ ﻋﺒـﺎرت‬ ‫‪ expression‬در ﻋﺪد 1– ﺿﺮب ﺷﺪﻩ و ﻧﺘﻴﺠﻪ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)10.1(‪Abs‬‬ ‫)10.1-(‪Abs‬‬ ‫ﻧﺘﻴﺠﻪ هﺮ دو اﻳﻦ دﺳﺘﻮرات، ﻋﺪد 10.1 ﺧﻮاهﺪ ﺑﻮد.‬ ‫)‪Atan(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ، ﺁرك ﺗﺎﻧﮋاﻧﺖ ﻳﻚ ﻣﻘﺪار را ﻣﺤﺎﺳﺒﻪ و ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ expression‬ﻣﻘﺪاري اﺳﺖ آﻪ ﺁرك ﺗﺎﻧﮋاﻧـﺖ ﺁن ﺑﺎﻳـﺪ ﻣﺤﺎﺳـﺒﻪ ﮔـﺮدد. ﻧﺘﻴﺠـﻪ اﻳـﻦ ﻣﺘـﺪ،‬ ‫ﻣﻘﺪاري ﺑﻴﻦ 97075.1– ﺗﺎ 97075.1 اﺳﺖ.‬ ‫ﻣﺜﺎل:‬ ‫61.1=)3.2(‪Atan‬‬ ‫)‪Cos(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ، آﺴﻴﻨﻮس ﻳﻚ زاوﻳﻪ را ﺑﺮ ﺣﺴﺐ رادﻳﺎن ﻣﺤﺎﺳﺒﻪ ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻋﺒﺎرﺗﻲ اﺳﺖ آﻪ ﺑﺎﻳﺪ آﺴﻴﻨﻮس ﺁن ﻣﺤﺎﺳﺒﻪ ﺷﻮد. ﺣﺎﺻـﻞ ﻣﺘـﺪ )(‪،Cos‬‬ ‫ﻣﻘﺪاري ﺑﻴﻦ 1– ﺗﺎ 1 اﺳﺖ.‬ ‫ﻣﺜﺎل:‬ ‫1=)0(‪Cos‬‬ ‫76.0-=)3.2(‪Cos‬‬ ‫)‪Exp(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ، ﺗﻮاﻧﻲ از ‪) e‬ﻋﺪد ﻧﭙﺮ( را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻧﻜﺘﻪ: ﺗﻘﺮﻳﺒﺎ 2817.2=‪e‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻣﻘﺪاري ﻋﺪدي)ﺗﻮاﻧﻲ( اﺳﺖ آﻪ ﺑﺎﻳﺪ ﻋﺪد ﻧﭙـﺮ ﺁن ﻣﺤﺎﺳـﺒﻪ ﮔـﺮدد و ﻣـﻲ‬ ‫ﺗﻮاﻧﺪ ﻳﻚ ﻋﺪد ﺻﺤﻴﺢ، اﻋﺸﺎري، ﻣﺜﺒﺖ ﻳﺎ ﻣﻨﻔﻲ ﺑﺎﺷﺪ.‬ ‫ﻣﺜﺎل:‬ ‫13.7=)2(‪Exp‬‬ ‫)‪Int(expression) , Fix(expression‬‬ ‫هﺮ دو اﻳﻦ ﻣﺘﺪهﺎ، ﻣﻘﺪاري ﻋﺪدي را درﻳﺎﻓﺖ آﺮدﻩ و ﻋﺪدي از ﻧﻮع ‪) Integer‬ﺻـﺤﻴﺢ( را ﺑﺮﮔـﺸﺖ‬ ‫ﻣﻲ دهﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ expression‬ﻋﺒﺎرﺗﻲ ﻋﺪدي اﺳﺖ آﻪ ﺑﻪ ﻋﻨﻮان ورودي اﻳﻦ ﻣﺘﺪهﺎ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٤٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫اﮔﺮ ﻣﻘﺪار ورودي، ﺻﺤﻴﺢ و ﻣﺜﺒﺖ ﻳﺎ ﻣﻨﻔﻲ ﺑﺎﺷﺪ، هﻤﺎن ﻣﻘﺪار ‪ expression‬ﺑﺮﮔـﺸﺖ دادﻩ ﻣـﻲ‬ ‫ﺷﻮد.‬ ‫اﮔﺮ ﻣﻘـﺪار ورودي، اﻋـﺸﺎري و ﻣﺜﺒـﺖ ﺑﺎﺷـﺪ، ﻗـﺴﻤﺖ اﻋـﺸﺎري ﺣـﺬف ﺷـﺪﻩ و ﻗـﺴﻤﺖ ﺻـﺤﻴﺢ‬ ‫ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫اﮔﺮ ﻣﻘﺪار ورودي، اﻋﺸﺎري و ﻣﻨﻔﻲ ﺑﺎﺷﺪ دو ﺣﺎﻟﺖ دارد:‬ ‫در ﺣﺎﻟﺖ اول اﮔﺮ از ﻣﺘـﺪ )(‪ Int‬اﺳـﺘﻔﺎدﻩ ﺷـﻮد، اوﻟـﻴﻦ ﻋـﺪد ﺻـﺤﻴﺢ ﻣﻨﻔـﻲ آـﻮﭼﻜﺘﺮ ﻳـﺎ ﻣـﺴﺎوي‬ ‫ﻋﺒﺎرت ورودي ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫در دوﻣﻴﻦ ﺣﺎﻟﺖ اﮔﺮ از ﻣﺘﺪ )(‪ Fix‬اﺳﺘﻔﺎدﻩ ﺷـﻮد، اوﻟـﻴﻦ ﻋـﺪد ﺻـﺤﻴﺢ ﻣﻨﻔـﻲ ﺑﺰرﮔﺘـﺮ ﻳـﺎ ﻣـﺴﺎوي‬ ‫ﻋﺒﺎرت ورودي ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﻣﺜﺎل هﺎي زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫21=)21(‪Int‬‬ ‫6=)6(‪Fix‬‬ ‫41=)32.41(‪Int‬‬ ‫052=)))5.2(‪Int(500/Int‬‬ ‫51=)5.51(‪Fix‬‬ ‫3-=)3.2-(‪Int‬‬ ‫2-=)3.2-(‪Fix‬‬ ‫ﭘﻴﺸﻨﻬﺎد ﻣﻲ آﻨﻢ اﮔﺮ ﻣﻲ ﺧﻮاهﻴﺪ آﻪ از دﺳﺖ ﻗﺴﻤﺖ اﻋﺸﺎري ﻳﻚ ﻋﺪد ﺧـﻼص ﺷـﻮﻳﺪ و ﺁن را‬ ‫اﺻﻄﻼﺣﺎ ﮔﺮد آﻨﻴﺪ، ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ آﻨﻴﺪ:‬ ‫)5.0+ ‪Int(value‬‬ ‫‪ ،Value‬ﻣﻘﺪاري ﻋﺪدي اﺳﺖ آﻪ ﻗﺼﺪ ﮔﺮد آﺮدن ﺁن را دارﻳﺪ.‬ ‫اﻳﻦ دﺳﺘﻮر، ﻓﺮﻣﺎن ﺑﺴﻴﺎر آﺎرﺁﻣﺪي ﺑﺮاي ﮔﺮدآﺮدن هﺮ ﻧـﻮع ﻣﻘـﺪاري ﻋـﺪدي اﺳـﺖ ﺑـﺎ اﻳـﻦ وﺟـﻮد،‬ ‫ﻣﺘﺪ )(‪ Round‬آﻪ در ﻗﺴﻤﺖ ﺑﻌﺪ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻩ اﺳﺖ ﺑﻪ ﺷﻴﻮﻩ اي ﺁﺳﺎﻧﺘﺮ، ﺑﻬﺘـﺮ و آﺎرﺁﻣـﺪﺗﺮ‬ ‫اﻳﻦ آﺎر را اﻧﺠﺎم ﻣﻲ دهﺪ.‬ ‫)] ‪Round(expression [,numdecimalplaces‬‬ ‫اﻳﻦ ﻣﺘﺪ، ﻳﻚ ﻋﺪد اﻋﺸﺎري را ﮔﺮد ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻣﻘﺪاري اﺳﺖ آﻪ ﺑﺎﻳﺪ ﮔﺮد ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ numdecimalplaces‬ﻣﺸﺨﺺ ﻣﻲ آﻨـﺪ آـﻪ اﻳـﻦ ﻣﻘـﺪار ﺗـﺎ ﭼﻨـﺪ رﻗـﻢ ﺑﻌـﺪ از‬ ‫اﻋــﺸﺎر ﺑﺎﻳــﺪ ﮔــﺮد ﺷــﻮد. اﮔــﺮ از ذآــﺮ اﻳــﻦ ﺁرﮔﻮﻣــﺎن ﺧــﻮدداري ﺷــﻮد، ﻳــﻚ ﻣﻘــﺪار از ﻧــﻮع ﺻــﺤﻴﺢ‬ ‫)‪ (Integer‬ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﻣﺜﺎل هﺎي زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫3=)94.3(‪Round‬‬ ‫4=)15.3(‪Round‬‬ ‫5.3=)1,94.3(‪Round‬‬ ‫5.3=)1,15.3(‪Round‬‬ ‫)‪Log(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ، ﻟﮕـﺎرﻳﺘﻢ ﻃﺒﻴﻌـﻲ )ﻳـﺎ ﻟﮕـﺎرﻳﺘﻢ ﭘﺎﻳـﻪ ‪ e‬آـﻪ ﺗﻘﺮﻳﺒـﺎ 2817.2=‪ e‬اﺳـﺖ( ﻣﻘـﺪاري را ﺑﺮﻣـﻲ‬ ‫ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻣﻘﺪاري ﻋﺪدي اﺳﺖ آﻪ ﻟﮕﺎرﻳﺘﻢ ﻃﺒﻴﻌﻲ ﺁن ﺑﺎﻳﺪ ﻣﺤﺎﺳـﺒﻪ ﺷـﻮد و ﺣﺘﻤـﺎ‬ ‫ﺑﺎﻳﺪ ﻣﻘﺪاري ﻣﺜﺒﺖ ﺑﺎﺷﺪ.‬ ‫ﻋﺒﺎرت ))‪ Log(Exp(N‬و ))‪ Exp(Log(N‬هﺮ دو ﻋﺪد ‪ N‬را ﺑﺮﻣﻲ ﮔﺮداﻧﻨﺪ.‬ ‫ﻟﮕﺎرﻳﺘﻢ ﻃﺒﻴﻌﻲ، ﻟﮕﺎرﻳﺘﻢ ﭘﺎﻳﻪ ﻋﺪد ‪) e‬ﻧﭙﺮ( اﺳﺖ.‬ ‫ﻣﻘﺪار دﻗﻴﻖ ﻋﺪد ﻧﭙﺮ را ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺎ دﺳﺘﻮر )1(‪ Exp‬ﺑﻪ دﺳﺖ ﺑﻴﺎورﻳﺪ.‬ ‫ﺑﺮاي ﻣﺤﺎﺳﺒﻪ ﻟﮕﺎرﻳﺘﻢ هﺎ در ﭘﺎﻳﻪ هـﺎي دﻳﮕـﺮ، ﻋـﺪد ﻟﮕـﺎرﻳﺘﻢ ﻃﺒﻴﻌـﻲ را ﺑـﺮ ﻟﮕـﺎرﻳﺘﻢ ﭘﺎﻳـﻪ ﺗﻘـﺴﻴﻢ‬ ‫آﻨﻴﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل، دﺳﺘﻮر زﻳﺮ ﻟﮕﺎرﻳﺘﻢ ﻳﻚ ﻋﺪد در ﭘﺎﻳﻪ ي 01 را ﻣﺤﺎﺳﺒﻪ ﻣﻲ آﻨﺪ.‬ ‫)01(‪Log10 =Log(number)/Log‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٥٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)‪Hex(expression) , Oct(expression‬‬ ‫اﻳـﻦ ﻣﺘـﺪهﺎ ﻋـﺪدي را ﺑـﻪ ﻋﻨـﻮان ورودي درﻳﺎﻓـﺖ آـﺮدﻩ و ﺁن را ﺑـﻪ ﻣﺒﻨـﺎي ٨ )‪ (Oct‬ﻳـﺎ ﻣﺒﻨـﺎي ٦١‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫)‪ (Hex‬ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﻨﺪ و ﺑﻪ ﺻﻮرت ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي )‪ (String‬ﺑﺮﮔﺸﺖ ﻣﻲ دهﻨﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻋﺒﺎرت )74(‪ ،Hex‬ﻣﻘﺪار ”‪ “2F‬و ﻋﺒـﺎرت )74(‪ Oct‬ﻣﻘـﺪار ”75“ را ﺑﺮﮔـﺸﺖ ﻣـﻲ‬ ‫دهﻨﺪ.‬ ‫ﺑﺮاي ﺗﻌﻴﻴﻦ آﺮدن اﻋﺪاد در ﻣﺒﻨﺎي ٦١، اﺑﺘﺪاي ﺁﻧﻬﺎ آﺎراآﺘﺮ ”‪ “&H‬را ﻗﺮار دهﻴﺪ.‬ ‫آﺎراآﺘﺮ و ﻧﻤﺎد ﻣﻌﺎدل ﺑﺮاي اﻋﺪاد در ﻣﺒﻨﺎي ٨، آﺎراآﺘﺮ ”0&“ ﻣﻲ ﺑﺎﺷﺪ.‬ ‫ﻓﺮض آﻨﻴﺪ ﻣﻘﺎدﻳﺮ زﻳﺮ ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﺑﺎﺷﻨﺪ:‬ ‫77‪Dvalue =199 : Ovalue =&O‬‬ ‫ﺣﺎل دﺳﺘﻮر )‪ ،Oct(Dvalue‬ﻣﻘﺪار رﺷﺘﻪ اي ”703“ و دﺳﺘﻮر )‪ Hex(Dvalue‬ﻣﻘﺪار رﺷﺘﻪ اي‬ ‫”‪ “3F‬را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﻣﻲ ﺗﻮاﻧﻴﺪ از آﺎراآﺘﺮهﺎي ﻣﻌﺎدل اﻳﻦ ﻣﺘﺪهﺎ ﻧﻴﺰ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ. ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)‪MsgBox (“The number 3F in decimal is “ & &H3F‬‬ ‫ﻣﻘﺪاري آﻪ ﻧﺸﺎن دادﻩ ﻣﻲ ﺷﻮد، ﻋﺪد 36 ﺧﻮاهﺪ ﺑﻮد.‬ ‫)2‪Pow(value1,value‬‬ ‫اﻳﻦ ﻣﺘﺪ، دو ﻋﺪد را ﺑﻪ ﻋﻨﻮان ورودي درﻳﺎﻓﺖ آﺮدﻩ و ﻋﺪد اول را ﺑﻪ ﺗﻮان ﻋﺪد دوم ﻣﻲ رﺳﺎﻧﺪ.‬ ‫دﺳﺘﻮر زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫))3,2(‪Console.WriteLine(Math.Pow‬‬ ‫در ﺧﺮوﺟﻲ، ﻋﺪد ٨ ﻧﻤﺎﻳﺶ دادﻩ ﺧﻮاهﺪ ﺷﻮد. ٢ ﺑﻪ ﺗﻮان ٣ ﺑﺮاﺑﺮ ﺑﺎ ٨ اﺳﺖ.‬ ‫)‪Sin(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ، ﺳﻴﻨﻮس زاوﻳﻪ اي را ﺑﺮ ﺣﺴﺐ رادﻳﺎن ﻣﺤﺎﺳﺒﻪ و ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻋﺒﺎرﺗﻲ اﺳﺖ آﻪ ﺳﻴﻨﻮس ﺁن ﺑﺎﻳﺪ ﻣﺤﺎﺳﺒﻪ ﺷﻮد.‬ ‫ﻧﺘﻴﺠﻪ ﻣﺘﺪ )(‪ ،Sin‬ﻣﻘﺪاري ﺑﻴﻦ 1 ﺗﺎ 1– اﺳﺖ.‬ ‫ﻣﺜﺎل:‬ ‫57.0 = )3.2(‪Sin‬‬ ‫)‪Sqrt(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ، ﻣﺮﺑﻊ )ﻋﺪد ﺑﻪ ﺗﻮان ٣( ﻳﻚ ﻣﻘﺪار ﻋﺪدي را ﻣﺤﺎﺳﺒﻪ و ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻋﺪدي اﺳﺖ آﻪ ﺑﺎﻳﺪ ﻣﺮﺑﻊ ﺁن ﻣﺤﺎﺳﺒﻪ ﺷﻮد.‬ ‫)‪Tan(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ، ﺗﺎﻧﮋاﻧﺖ زاوﻳﻪ اي را ﺑﺮ ﺣﺴﺐ رادﻳﺎن ﻣﺤﺎﺳﺒﻪ ﻣﻲ آﻨﺪ.‬ ‫ﻣﺜﺎل:‬ ‫21.1- = )3.2(‪Tan‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٦٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)‪:(Date and Time‬‬ ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ ﺗﺎرﻳﺦ و زﻣﺎن ﺳﺮ و آﺎر دارﻧﺪ‬ ‫ﺗﻮاﺑﻊ آﺎرﺑﺮدي و آﺎرﺁﻣﺪي ﺟﻬﺖ آﺎر ﺑﺎ ﺗﺎرﻳﺦ و زﻣﺎن در ‪ VB.NET‬وﺟـﻮد دارد آـﻪ ﻣﻤﻜـﻦ اﺳـﺖ در‬ ‫ﺑﺮﺧﻮرد اول ﺑﺎ اﻳﻦ ﺗﻮاﺑﻊ، از ﺗﻨﻮع ﺁﻧﻬﺎ ﺗﻌﺠﺐ آﻨﻴﺪ!‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: در ‪ ،VB‬ﻣﻘﺎدﻳﺮي آﻪ از ﻧﻮع ﺗﺎرﻳﺦ هﺴﺘﻨﺪ ﺑﺎﻳﺪ ﺣﺘﻤﺎ ﺑﻴﻦ دو ﻋﻼﻣﺖ )#( ﻗﺮار ﮔﻴﺮﻧﺪ.‬ ‫)(‪Now‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺗﺎرﻳﺦ و زﻣﺎن ﺟﺎري ﺳﻴﺴﺘﻢ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻣﺜﺎل:‬ ‫))(‪MsgBox(Now‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل، ﺧﺮوﺟﻲ دﺳﺘﻮر ﻓﻮق ﻣﻲ ﺗﻮاﻧﺪ ”‪ “02/10/2004 09:23:10 PM‬ﺑﺎﺷﺪ.‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﺗﺎرﻳﺦ و زﻣﺎن ﺑﺎ آﺎراآﺘﺮ ﺧﺎﻟﻲ )‪ (Blank‬از هﻢ ﺟﺪا ﺷﺪﻩ اﻧﺪ.‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: ﺑﺮاي اﺳﺘﺨﺮاج ﺗﻨﻬﺎ ﺗﺎرﻳﺦ ﻳﺎ زﻣﺎن ﺑﺮﮔﺸﺖ دادﻩ ﺷـﺪﻩ از اﻳـﻦ ﺗـﺎﺑﻊ، از ﺧـﻮاص ‪ Date‬و‬ ‫‪ TimeOfDay‬اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫)‪Console.WriteLine(Now.Date.ToString‬‬ ‫)‪Console.WriteLine(Now.TimeOfDay.ToString‬‬ ‫)‪Day(date‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ را ﺑﻪ ﻋﻨﻮان ورودي ﻣﻲ ﭘﺬﻳﺮد و روز ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔﺮ ﻣﻘﺪار ورودي، ﺗﺎرﻳﺦ 4002/51/21 ﺑﺎﺷﺪ، ﻣﻘﺪار ﺧﺮوﺟﻲ ﻋـﺪد 51 ﻳﻌﻨـﻲ روز‬ ‫ﺗﺎرﻳﺦ ﺧﻮاهﺪ ﺑﻮد.‬ ‫ﻣﺜﺎل زﻳﺮ روز ﺟﺎري ﺳﻴﺴﺘﻢ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫))(‪Day(Now‬‬ ‫)] ‪Weekday(date [,firstdayofweek‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻋﺪدي ﺑﻴﻦ 1 ﺗﺎ 7 را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ آﻪ ﻣﺸﺨﺺ آﻨﻨﺪﻩ روز هﻔﺘﻪ اﺳﺖ.‬ ‫ﻣﺜﻼ، 1 ﺑﺮاي ‪ 2 ،Sunday‬ﺑﺮاي ‪ Monday‬و ﺑﻪ هﻤﻴﻦ ﺗﺮﺗﻴﺐ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ date‬ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،firstdayofweek‬اوﻟﻴﻦ روز هﻔﺘﻪ را ﻣﺸﺨﺺ ﻣـﻲ آﻨـﺪ و ﻣـﻲ ﺗﻮاﻧـﺪ ﻳﻜـﻲ از‬ ‫ﻣﻘﺎدﻳﺮ زﻳﺮ را ﺑﭙﺬﻳﺮد:‬ ‫ﻣﻘﺪار اﻳﻦ ﺁرﮔﻮﻣﺎن ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ‪ Sunday‬ﻳﻌﻨﻲ ﻳﻜﺸﻨﺒﻪ اﺳﺖ.‬ ‫ﻣﻄﺎﺑﻖ ﺑﺎ ﺗﻨﻈﻴﻤﺎت ﺳﻴﺴﺘﻢ >>> 0 ﻳﺎ ‪System‬‬ ‫ﻳﻜﺸﻨﺒﻪ )ﻣﻘﺪار ﭘﻴﺶ ﻓﺮض( >>> 1 ﻳﺎ ‪Sunday‬‬ ‫دوﺷﻨﺒﻪ >>> 2 ﻳﺎ ‪Monday‬‬ ‫ﺳﻪ ﺷﻨﺒﻪ >>> 3 ﻳﺎ ‪Tuesday‬‬ ‫ﭼﻬﺎرﺷﻨﺒﻪ >>> 4 ﻳﺎ ‪Wednesday‬‬ ‫ﭘﻨﺞ ﺷﻨﺒﻪ >>> 5 ﻳﺎ ‪Thursday‬‬ ‫ﺟﻤﻌﻪ >>> 6 ﻳﺎ ‪Friday‬‬ ‫ﺷﻨﺒﻪ >>> 7 ﻳﺎ ‪Saturday‬‬ ‫)]] ‪WeekdayName(weekday [,abbreviate [,firstdayofweek‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ هﻤﺎﻧﻨﺪ ﺗﺎﺑﻊ )(‪ Weekday‬ﻋﻤﻞ ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ اﻳـﻦ ﺗـﺎﺑﻊ، ﻧـﺎم روز ﻣﻌـﺎدل ﻳـﻚ‬ ‫ﻋﺪد آﻪ ﺑﻴﻦ 1 ﺗﺎ 7 اﺳﺖ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ weekday‬ﻳﻚ ﻣﻘﺪار ﻋﺪدي ﺻﺤﻴﺢ اﺳﺖ و ﻋﺪدي ﺑﻴﻦ 1 ﺗﺎ 7 را ﻣﻲ ﭘﺬﻳﺮد.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،abbreviate‬ﻳﻚ ﻣﻘﺪار ﻣﻨﻄﻘﻲ )‪ (Boolean‬اﺳﺖ آﻪ ﻣﺸﺨﺺ ﻣـﻲ آﻨـﺪ ﺁﻳـﺎ‬ ‫ﻧﺎم روزي آﻪ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد ﺑﻪ ﺻﻮرت آﻮﺗـﺎﻩ و اﺧﺘـﺼﺎري ﺑﺎﺷـﺪ ﻳـﺎ ﺧﻴـﺮ. ﺑـﻪ ﻃـﻮر ﭘـﻴﺶ‬ ‫ﻓﺮض اﻳﻦ ﻣﻘﺪار ‪ False‬اﺳﺖ ﻳﻌﻨﻲ ﻧﺎم ﺑﻪ ﺻﻮرت آﺎﻣﻞ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٧٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ firstdayofweek‬ﻧﻴﺰ اوﻟﻴﻦ روز هﻔﺘﻪ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ و ﻣﻲ ﺗﻮاﻧﺪ ﻳﻜـﻲ از‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ ﺁرﮔﻮﻣﺎن ‪ firstdayofweek‬از ﺗﺎﺑﻊ ‪ Weekday‬ﻣﻲ ﭘﺬﻳﺮد، ﺑﭙﺬﻳﺮد.‬ ‫ﻣﻘﺪار اﻳﻦ ﺁرﮔﻮﻣﺎن ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ‪ Sunday‬ﻳﻌﻨﻲ ﻳﻜﺸﻨﺒﻪ اﺳﺖ.‬ ‫)‪Month(date‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ از ﻣﻘﺪار ﺗﺎرﻳﺦ، ﻣﺎﻩ ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ آﻪ ﻋﺪدي ﺑﻴﻦ 1 ﺗﺎ 21 اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،date‬ﻣﻘﺪاري از ﻧﻮع ﺗﺎرﻳﺦ اﺳﺖ آﻪ ﻣﺎﻩ ﺁن ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺑﺮاي ﺑﻪ دﺳـﺖ ﺁوردن ﻋـﺪد ﻣﺘﻨـﺎﻇﺮ ﻣـﺎﻩ ﺟـﺎري ﺳﻴـﺴﺘﻢ از دﺳـﺘﻮر زﻳـﺮ اﺳـﺘﻔﺎدﻩ‬ ‫آﻨﻴﺪ:‬ ‫))(‪Month(Date‬‬ ‫)] ‪MonthName(month [,abbreviate‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻧﻴﺰ هﻤﺎﻧﻨﺪ ﺗﺎﺑﻊ )(‪ Month‬ﻋﻤﻞ ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ ﺑﻪ ﺟﺎي ﻋﺪد ﻣـﺎﻩ، ﻧـﺎم ﻣـﺎﻩ را‬ ‫ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،month‬ﻣﻘﺪاري ﻋﺪدي و ﺑـﻴﻦ 1 ﺗـﺎ 21 اﺳـﺖ آـﻪ ﺑﺎﻳـﺪ ﻣـﺎﻩ ﻣﺘﻨـﺎﻇﺮ ﺁن ﺑﺮﮔـﺸﺖ دادﻩ‬ ‫ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،abbreviate‬ﻳﻚ ﻣﻘﺪار ﻣﻨﻄﻘﻲ )‪ (Boolean‬اﺳﺖ آﻪ ﻣﺸﺨﺺ ﻣـﻲ آﻨـﺪ ﺁﻳـﺎ‬ ‫ﻧﺎم ﻣﺎهﻲ آﻪ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد ﺑﻪ ﺻﻮرت آﻮﺗﺎﻩ و اﺧﺘـﺼﺎري ﺑﺎﺷـﺪ ﻳـﺎ ﺧﻴـﺮ. ﺑـﻪ ﻃـﻮر ﭘـﻴﺶ‬ ‫ﻓﺮض اﻳﻦ ﻣﻘﺪار ‪ False‬اﺳﺖ ﻳﻌﻨﻲ ﻧﺎم ﻣﺎﻩ ﺑﻪ ﺻﻮرت آﺎﻣﻞ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫)‪Year(date‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ از ﻣﻘﺪار ﺗﺎرﻳﺦ، ﺳﺎل ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻣﻘﺪاري آﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﻣﻲ ﮔﺮداﻧﺪ، ﻋﺪدي ﺑﻴﻦ 0 ﺗﺎ 9999 ﻣﻲ ﺑﺎﺷﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،date‬ﻣﻘﺪاري از ﻧﻮع ﺗﺎرﻳﺦ اﺳﺖ آﻪ ﺳﺎل ﺁن ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺑﺮاي ﺑﻪ دﺳﺖ ﺁوردن ﻋﺪد ﻣﺘﻨﺎﻇﺮ ﺳـﺎل ﺟـﺎري ﺳﻴـﺴﺘﻢ از دﺳـﺘﻮر زﻳـﺮ اﺳـﺘﻔﺎدﻩ‬ ‫آﻨﻴﺪ:‬ ‫))(‪Year(Now‬‬ ‫)‪Hour(time‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ از ﻣﻘﺪار زﻣﺎن، ﺑﺨﺶ ﺳﺎﻋﺖ ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻣﻘﺪاري آﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﻣﻲ ﮔﺮداﻧﺪ ﺑﻴﻦ 0 ﺗﺎ 42 اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،Time‬ﻣﻘﺪاري از ﻧﻮع زﻣﺎن )‪ (Time‬اﺳﺖ آﻪ ﺳﺎﻋﺖ ﺁن ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل دﺳﺘﻮر زﻳﺮ ﺳﺎﻋﺖ ﺟﺎري ﺳﻴﺴﺘﻢ را ﻧﺸﺎن ﻣﻲ دهﺪ:‬ ‫)))(‪Console.WriteLine(Hour(Now‬‬ ‫)‪Minute(time‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ از ﻣﻘﺪار زﻣﺎن، دﻗﻴﻘﻪ ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻣﻘﺪاري آﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﻣﻲ ﮔﺮداﻧﺪ ﺑﻴﻦ 0 ﺗﺎ 95 اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،time‬ﻣﻘﺪاري از ﻧﻮع زﻣﺎن اﺳﺖ آﻪ دﻗﻴﻘﻪ ﺁن ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل دﺳﺘﻮر زﻳﺮ دﻗﻴﻘﻪ ﺟﺎري ﺳﻴﺴﺘﻢ را ﻧﺸﺎن ﻣﻲ دهﺪ:‬ ‫)))(‪Console.WriteLine(Minute(Now‬‬ ‫)‪Second(time‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ از ﻣﻘﺪار زﻣﺎن، ﺛﺎﻧﻴﻪ ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻣﻘﺪاري آﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﻣﻲ ﮔﺮداﻧﺪ ﺑﻴﻦ 0 ﺗﺎ 95 اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،time‬ﻣﻘﺪاري از ﻧﻮع زﻣﺎن اﺳﺖ آﻪ ﺛﺎﻧﻴﻪ ﺁن ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل دﺳﺘﻮر زﻳﺮ ﺛﺎﻧﻴﻪ ﺟﺎري ﺳﻴﺴﺘﻢ را ﻧﺸﺎن ﻣﻲ دهﺪ:‬ ‫)))(‪Console.WriteLine(Second(Now‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٨٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)‪DateSerial(year,month,day‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺳﻪ ﻋﺪد ﺻﺤﻴﺢ را ﺑﻪ ﻋﻨﻮان ورودي درﻳﺎﻓﺖ آﺮدﻩ و ﺁن را ﺑﻪ ﺗﺎرﻳﺦ ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن هﺎي ‪ month،year‬و ‪ day‬ﺑﻪ ﺗﺮﺗﻴﺐ ﺳﺎل، ﻣﺎﻩ و روز هﺴﺘﻨﺪ.‬ ‫دﺳﺘﻮر زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫))1,01,2002(‪Console.WriteLine(DateSerial‬‬ ‫ﺧﺮوﺟﻲ اﻳﻦ دﺳﺘﻮر، رﺷﺘﻪ ي ”2002/01/10“ ﺧﻮاهﺪ ﺑﻮد.‬ ‫هﻤﭽﻨﻴﻦ از اﻳﻦ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺟﻬﺖ ﺑﺮﺧﻲ ﻣﺤﺎﺳﺒﺎت ﺑﺮ روي ﻣﻘﺪار ﺗﺎرﻳﺦ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻓﺮض آﻨﻴﺪ ﻣﻲ ﺧﻮاهﻴﺪ ﺑﺪاﻧﻴﺪ آﻪ ﻧﻮدﻣﻴﻦ روز ﺳـﺎل در ﭼـﻪ ﺗـﺎرﻳﺨﻲ از ﺳـﺎل ﻗـﺮار‬ ‫ﺧﻮاهﺪ ﮔﺮﻓﺖ. ﻣﻲ ﺗﻮاﻧﻴﺪ از دﺳﺘﻮر زﻳﺮ ﺟﻬﺖ ﺁﮔﺎهﻲ از اﻳﻦ ﻣﻮﺿﻮع اﺳﺘﻔﺎدﻩ آﻨﻴﺪ:‬ ‫))09,1,6991(‪Console.WriteLine(DateSerial‬‬ ‫ﺧﺮوﺟﻲ اﻳﻦ دﺳﺘﻮر، ﻋﺒﺎرت ”6991/03/30“ ﺧﻮاهﺪ ﺑﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎﻟﻲ دﻳﮕـﺮ ﻣـﻲ ﺧـﻮاهﻴﻢ ﺑـﺪاﻧﻴﻢ آـﻪ ٠٠٠١ روز ﺑﻌـﺪ از ﺗـﺎرﻳﺦ ﻓﻌﻠـﻲ ﺳﻴـﺴﺘﻢ در ﭼـﻪ‬ ‫ﺗﺎرﻳﺨﻲ ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ. ﭘﺲ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ:‬ ‫))0001+)‪Console.WriteLine(DateSerial(Year(Now.Date),Month(Now.Date),Weekday(Now.Date‬‬ ‫ﺷﻤﺎ هﻤﭽﻨﻴﻦ ﻗﺎدر ﺑﻪ اﺿﺎﻓﻪ آﺮدن ﻳﺎ آﻢ آﺮدن )ﺗﻔﺮﻳﻖ آﺮدن( ﻳﻚ ﻋﺪد ﻣﺘﻨﺎﻇﺮ ﻣﺎﻩ هﺎ ﺑﻪ ﺁرﮔﻮﻣـﺎن‬ ‫‪ month‬و هﻤﭽﻨﻴﻦ ﻳﻚ ﻋﺪد ﻣﺘﻨﺎﻇﺮ ﺳﺎل ﺑﻪ ﺁرﮔﻮﻣﺎن ‪ year‬هﺴﺘﻴﺪ.‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﺗﻌﺪاد روزهﺎي هﺮ ﻣﺎﻩ در اﻳﻦ ﺗﺎﺑﻊ ٠٣ روز اﺳﺖ.‬ ‫)‪DateValue(date‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻋﺒﺎرت رﺷﺘﻪ اي را ﺑﻪ ﻋﻨﻮان ورودي درﻳﺎﻓﺖ آﺮدﻩ و ﺁن را ﺑﻪ ﻳﻚ ﻣﻘـﺪار از ﻧـﻮع ﺗـﺎرﻳﺦ‬ ‫ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔﺮ اﻳﻦ ﺗﺎﺑﻊ را ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺑﻪ آﺎر ﺑﺒﺮﻳﻢ:‬ ‫))”2002 ,52 ‪Console.WriteLine(DateValue(“December‬‬ ‫ﻋﺒﺎرﺗﻲ آﻪ در ﺧﺮوﺟﻲ ﭼﺎپ ﻣﻲ ﺷﻮد، ”2002/52/21“ ﺧﻮاهﺪ ﺑﻮد.‬ ‫ﻳﻜﻲ از آﺎرﺑﺮدهﺎي ﺳﻮدﻣﻨﺪ و ﻣﻔﻴﺪ اﻳﻦ ﺗﺎﺑﻊ در هﻨﮕﺎﻣﻲ اﺳـﺖ آـﻪ ﺑـﺎ ﺗـﺎﺑﻊ )(‪ DateDiff‬ﺑـﻪ آـﺎر‬ ‫رود.‬ ‫ﺗﺎﺑﻊ )(‪ DateDiff‬در اداﻣﻪ ﺗﻮﺿﻴﺢ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﻓﺮض آﻨﻴﺪ ﻣﻲ ﺧﻮاهﻴﻢ ﺗﻌﺪاد روزهﺎي ﺑﻴﻦ دو ﺗﺎرﻳﺦ را ﻣﺤﺎﺳﺒﻪ آﻨﻴﻢ:‬ ‫دﺳﺘﻮر زﻳﺮ اﻳﻦ آﺎر را ﺑﺮاي ﻣﺎ اﻧﺠﺎم ﻣﻲ دهﺪ:‬ ‫_ ,)”3991/52/21“(‪Console.WriteLine((DateDiff(DateInterval.Day,DateValue‬‬ ‫)))” 6991/52/21“(‪DateValue‬‬ ‫ﻋﺪدي آﻪ در ﺧﺮوﺟﻲ ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ، 6901 ﻳﻌﻨﻲ ﺗﻌﺪاد روزهـﺎي ﺑـﻴﻦ اﻳـﻦ دو ﺗـﺎرﻳﺦ ﺧﻮاهـﺪ‬ ‫ﺑﻮد.‬ ‫)‪TimeSerial(hours,minutes,seconds‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺳﻪ ﻋﺪد ﺻﺤﻴﺢ را ﺑﻪ زﻣﺎن ﻣﺸﺨﺼﻲ ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن هﺎي ‪ Minute ،Hour‬و ‪ Second‬ﺑﻪ ﺗﺮﺗﻴﺐ اﻋﺪاد ﺻﺤﻴﺤﻲ هﺴﺘﻨﺪ آﻪ ﺳـﺎﻋﺖ، دﻗﻴﻘـﻪ‬ ‫و ﺛﺎﻧﻴﻪ را آﻪ ﺑﺎﻳﺪ ﺑﻪ زﻣﺎن ﺗﺒﺪﻳﻞ ﺷﻮﻧﺪ، ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)55,01,4(‪TimeSerial‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻣﻘﺪار "‪ “4:10:55 AM‬را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻣﻌﻤﻮﻻ ﺑﺮاي ﻣﺤﺎﺳﺒﻪ ي زﻣﺎن ﺑﻪ آﺎر ﻣﻲ رود.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٩٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل، ﻓﺮاﺧﻮاﻧﻲ ﺗﺎﺑﻊ )(‪ TimeSerial‬ﺑﻪ ﺷﻜﻞ زﻳـﺮ، ٢ ﺳـﺎﻋﺖ و ٥١ دﻗﻴﻘـﻪ و ٢٣ ﺛﺎﻧﻴـﻪ‬ ‫ﻗﺒﻞ از ﺳﺎﻋﺖ ‪ 4:13:40 PM‬را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫)23- 04,51- 31,2- 61(‪TimeSerial‬‬ ‫زﻣﺎن ﺑﺮﮔﺸﺘﻲ، ‪ 1:58:08 PM‬ﺧﻮاهﺪ ﺑﻮد.‬ ‫)‪TimeValue(time‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي را درﻳﺎﻓﺖ آﺮدﻩ و ﺁن را ﺑﻪ ﻣﻘﺪار زﻣﺎﻧﻲ ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ.‬ ‫هﻤﺎﻧﻨﺪ ﺗﺎﺑﻊ )(‪ ،DateValue‬اﻳﻦ ﺗﺎﺑﻊ ﻧﻴﺰ ﻣﻲ ﺗﻮاﻧﺪ ﺟﻬﺖ اﻧﺠـﺎم ﻋﻤﻠﻴـﺎﺗﻲ ﻧﻈﻴـﺮ ﺟﻤـﻊ ﻳـﺎ ﺗﻔﺮﻳـﻖ‬ ‫زﻣﺎن هﺎ ﺑﻪ آﺎر رود.‬ ‫)‪DateAdd(interval,number,date‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ هﻤﺎن ﻃﻮر آﻪ از ﻧـﺎم ﺁن ﻧﻴـﺰ ﭘﻴﺪاﺳـﺖ، ﻣﻘـﺪاري را ﺑـﻪ ﺗـﺎرﻳﺨﻲ ﻣـﺸﺨﺺ اﺿـﺎﻓﻪ آـﺮدﻩ و‬ ‫ﺗﺎرﻳﺦ ﺟﺪﻳﺪ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،interval‬ﻳﻚ واﺣﺪ زﻣﺎﻧﻲ هﻤﺎﻧﻨﺪ روز، ﺳﺎﻋﺖ، هﻔﺘﻪ و … اﺳﺖ آـﻪ ﻓﺎﺻـﻠﻪ دورﻩ اي را‬ ‫ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ ﺗﺎرﻳﺦ ﺟﺪﻳﺪ ﺑﺎﻳﺪ ﺑﺮ ﺣﺴﺐ ﺁن ﻣﺤﺎﺳـﺒﻪ و ﺑﺮﮔـﺸﺖ دادﻩ ﺷـﻮد و ﻣـﻲ ﺗﻮاﻧـﺪ‬ ‫ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ زﻳﺮ را ﺑﭙﺬﻳﺮد:‬ ‫ﺳﺎل :‪Year‬‬ ‫ﻳﻚ ﭼﻬﺎرم ﺳﺎل ﻳﺎ ٣ ﻣﺎﻩ ﻳﺎ ﻳﻚ ﻓﺼﻞ :‪Quarter‬‬ ‫ﻣﺎﻩ :‪Month‬‬ ‫روز از ﺳﺎل :‪DayOfYear‬‬ ‫روز :‪Day‬‬ ‫روز از هﻔﺘﻪ :‪WeekDay‬‬ ‫هﻔﺘﻪ از ﺳﺎل :‪WeekOfYear‬‬ ‫ﺳﺎﻋﺖ :‪Hour‬‬ ‫دﻗﻴﻘﻪ :‪Minute‬‬ ‫ﺛﺎﻧﻴﻪ :‪Second‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،number‬ﺗﻌﺪاد هﺮ دورﻩ ي زﻣﺎﻧﻲ را ﻣﺸﺨﺺ ﻣﻲ آﻨـﺪ. ﻣـﺜﻼ ﻣﻤﻜـﻦ اﺳـﺖ ﺑﺨـﻮاهﻴﻢ‬ ‫ﺑﺪاﻧﻴﻢ آﻪ ٣ ﻣﺎﻩ ﺑﻌﺪ از ﺗﺎرﻳﺦ ﻓﻌﻠﻲ ﺳﻴﺴﺘﻢ ﭼﻪ ﺗﺎرﻳﺨﻲ ﻣﻲ ﺷﻮد ﭘﺲ اﻳﻦ ﭘـﺎراﻣﺘﺮ را ﺑﺮاﺑـﺮ ﺑـﺎ ٣‬ ‫ﻗﺮار ﻣﻲ دهﻴﻢ.‬ ‫ﻧﻜﺘﻪ: اﮔﺮ اﻳﻦ ﺁرﮔﻮﻣﺎن ﻋﺪدي ﻣﺜﺒﺖ ﺑﺎﺷﺪ، ﺗﺎرﻳﺨﻲ آﻪ ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﺪ ﺷﺪ ﻣﺮﺑﻮط ﺑـﻪ ﺁﻳﻨـﺪﻩ‬ ‫اﺳﺖ و اﮔﺮ اﻳﻦ ﺁرﮔﻮﻣﺎن، ﻣﻨﻔﻲ ﺑﺎﺷﺪ، ﺗﺎرﻳﺨﻲ آﻪ ﻧﺸﺎن دادﻩ ﻣﻲ ﺷﻮد ﻣﺮﺑﻮط ﺑـﻪ ﮔﺬﺷـﺘﻪ ﻣـﻲ‬ ‫ﺑﺎﺷﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ date‬ﻧﻴﺰ ﺗﺎرﻳﺨﻲ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ ﻋﻤﻠﻴﺎت ﺑﺎﻳﺪ ﺑﺮ روي ﺁن اﻧﺠﺎم ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻣﻲ ﺧﻮاهﻴﻢ ﺑﺪاﻧﻴﻢ آﻪ ١ ﻣﺎﻩ ﺑﻌﺪ از ١٣ دﺳـﺎﻣﺒﺮ ﺳـﺎل ٢٠٠٢، ﭼـﻪ ﺗـﺎرﻳﺨﻲ ﻣـﻲ‬ ‫ﺷﻮد. ﭘﺲ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ:‬ ‫))#2002/13/21#,1,‪Console.WriteLine(DateAdd(DateInterval.Month‬‬ ‫ﻧﺘﻴﺠﻪ اﻳﻦ دﺳﺘﻮر، ﻋﺒﺎرت ”‪ “1/31/2003 12:00:00 AM‬ﺧﻮاهﺪ ﺑﻮد.‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﺎ ﺣﺪ زﻳﺎدي ﺷﺒﻴﻪ ﺑﻪ ﺗﺎﺑﻊ )(‪ DateSerial‬اﺳﺖ آﻪ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪ ﺑﺎ اﻳـﻦ ﺗﻔـﺎوت آـﻪ‬ ‫ﺗﻌﺪاد روزهﺎي هﺮ ﻣﺎﻩ در اﻳﻦ ﺗﺎﺑﻊ ﺑﻨﺎ ﺑﻪ ﻧﺎم ﻣﺎﻩ ﻓﺮق ﻣﻲ آﻨﺪ ﻣﺜﻼ ﻣﻤﻜﻦ اﺳﺖ ﻳﻚ ﻣﺎﻩ ٠٣ ﻳـﺎ ١٣‬ ‫روز ﺑﺎﺷﺪ اﻣﺎ ﺗﻌﺪاد روزهﺎي ﻣﺎﻩ در ﺗﺎﺑﻊ )(‪ ،DateSerial‬ﺛﺎﺑﺖ و ٠٣ روز ﻣﻲ ﺑﺎﺷﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫#2002/13/1#= 1‪day‬‬ ‫)))1‪Console.WriteLine(DateSerial(year(day1),month(day1)+1,day(day‬‬ ‫ﻧﺘﻴﺠﻪ ﻋﺒﺎرت، ”20/2/3“ ﺧﻮاهﺪ ﺑﻮد آﻪ ﻳﻚ ﺗﺎرﻳﺦ در ﻣﺎﻩ ﻣﺎرس اﺳﺖ ﻧﻪ ﻓﻮرﻳﻪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٠٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)]] ‪DateDiff(interval,date1,date2 [,firstdayofweek [,firstweekofyear‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺷﻜﻞ ﭘﻴﺸﺮﻓﺘﻪ ﺗﺮ ﺗﺎﺑﻊ )(‪ DateAdd‬اﺳﺖ و اﺧﺘﻼف ﺑﻴﻦ دو ﺗﺎرﻳﺦ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ interval‬ﻳﻚ ﻣﻘﺪار ﺛﺎﺑﺖ اﺳﺖ و ﻓﻮاﺻـﻞ ﺑـﻴﻦ دورﻩ اي را ﻣـﺸﺨﺺ ﻣـﻲ آﻨـﺪ آـﻪ ﺷـﻤﺎ‬ ‫ﺑﺮاي ﻣﺤﺎﺳﺒﻪ اﺧﺘﻼف ﺑﻴﻦ دو ﺗﺎرﻳﺦ ﺑﻪ آﺎر ﻣﻲ ﺑﺮﻳﺪ.‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ اﻳﻦ ﺁرﮔﻮﻣﺎن ﻣﻲ ﺗﻮاﻧﺪ ﺑﭙﺬﻳﺮد هﻤﺎن ﻣﻘﺎدﻳﺮي هﺴﺘﻨﺪ آﻪ ﺁرﮔﻮﻣـﺎن ‪ interval‬ﺗـﺎﺑﻊ‬ ‫)(‪ DateAdd‬ﻣﻲ ﺗﻮاﻧﺪ ﺑﭙﺬﻳﺮد.‬ ‫ﺁرﮔﻮﻣﺎن هﺎي 1‪ date‬و 2‪ date‬ﺗﺎرﻳﺦ هﺎﻳﻲ هﺴﺘﻨﺪ آﻪ اﺧﺘﻼف ﺁﻧﻬﺎ ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﻧﻜﺘﻪ: هﻤﻴﺸﻪ ﻣﻘﺪار 2‪ date‬از 1‪ date‬آﻢ ﻣﻲ ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن هﺎي اﺧﺘﻴﺎري ‪ firstdayofweek‬و ‪ firstweekofyear‬ﻧﻴﺰ ﺑﻪ ﺗﺮﺗﻴﺐ، اوﻟﻴﻦ روز هﻔﺘـﻪ و‬ ‫اوﻟﻴﻦ هﻔﺘﻪ ﺳﺎل را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﻨﺪ.‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ اﻳﻦ ﺁرﮔﻮﻣﺎن هﺎ ﻣﻲ ﺗﻮاﻧﻨﺪ ﺑﭙﺬﻳﺮﻧـﺪ، هﻤـﺎن ﻣﻘـﺎدﻳﺮ ﺁرﮔﻮﻣـﺎن ‪ firstdayofweek‬از‬ ‫ﺗﺎﺑﻊ )(‪ Format‬اﺳﺖ آﻪ ﭘﻴﺸﺘﺮ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪ. )ﺑﻪ ﺗﻮﺿﻴﺤﺎت ﺗﺎﺑﻊ )(‪ format‬ﻣﺮاﺟﻌﻪ آﻨﻴﺪ(‬ ‫ﻣﺜﻼ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ از اﻳﻦ ﺗﺎﺑﻊ ﺑﺮاي اﻃﻼع از ﺗﻌﺪاد روزهﺎ، هﻔﺘﻪ هﺎ، ﺛﺎﻧﻴﻪ هﺎ و … ﺑﻴﻦ دو ﺗـﺎرﻳﺦ‬ ‫اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ ﺗﻌﺪاد روزهﺎي ﺑﻴﻦ ﻳﻚ ﺗﺎرﻳﺦ ﻣﺸﺨﺺ ﺷﺪﻩ و ﺗﺎرﻳﺦ ﻓﻌﻠﻲ ﺳﻴﺴﺘﻢ را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ:‬ ‫‪Dim century As Date‬‬ ‫#0002/1/1#= ‪century‬‬ ‫)))(‪MsgBox(DateDiff(DateInterval.Day,century,Now‬‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: ﺗﻮاﺑﻊ ‪ DateDiff‬و ‪ TimeSerial‬در ﭘﺮوژﻩ هـﺎي وب و ﻣﺨـﺼﻮﺻﺎ ﻓـﻮروم هـﺎﻳﻲ آـﻪ ﺑـﻪ‬ ‫وﺳﻴﻠﻪ ي زﺑﺎن ‪ ASP.NET‬اﻳﺠﺎد ﻣﻲ ﺷﻮﻧﺪ، آﺎرﺑﺮد ﻓﺮاواﻧﻲ دارﻧﺪ.‬ ‫ﻳﻚ ﻧﻜﺘﻪ ي ﺑﺴﻴﺎر ﻣﻬﻢ: ﻧﻜﺘﻪ اي آﻪ ﻣﺘﺎﺳﻔﺎﻧﻪ در اآﺜﺮ ﭘﺮوژﻩ هﺎي وب در اﻳﺮان رﻋﺎﻳﺖ ﻧﻤﻲ ﺷﻮد‬ ‫اﻳﻦ اﺳﺖ آﻪ ﺳﺎﻋﺖ رﺳﻤﻲ اﻳﺮان در روز اول ﻓﺮوردﻳﻦ ﻳﻚ ﺳﺎﻋﺖ ﺑﻪ ﺟﻠـﻮ آـﺸﻴﺪﻩ ﻣـﻲ ﺷـﻮد و‬ ‫در اﻳﻦ ﺣﺎﻟﺖ، ﺳﺎﻋﺖ آﺸﻮر ﻣﺎ از ﮔﺮﻳﻨﻮﻳﭻ، ٠٣:٤ ﺳـﺎﻋﺖ ﺟﻠـﻮﺗﺮ اﺳـﺖ، در ﺣـﺎﻟﻲ آـﻪ در روز ١٣‬ ‫ﺷﻬﺮﻳﻮر ﻳﻚ ﺳﺎﻋﺖ ﺑﻪ ﻋﻘﺐ آﺸﻴﺪﻩ ﻣﻲ ﺷﻮد و ﺑﻪ ﺣﺎﻟﺖ اوﻟﻴﻪ ﺧﻮد ﺑﺎز ﻣﻲ ﮔﺮدد ﻳﻌﻨـﻲ 5.3+‬ ‫‪GMT‬‬ ‫)]] ‪DatePart(interval,date [,firstdayofweek [,firstweekofyear‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺑﺨﺸﻲ از ﻳﻚ ﺗﺎرﻳﺦ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ interval‬ﺑﺨﺸﻲ اﺳﺖ آﻪ ﺑﺎﻳﺪ از ﺗﺎرﻳﺦ اﺳﺘﺨﺮاج ﺷﻮد و هﻤﺎن ﻣﻘﺎدﻳﺮي را ﻣـﻲ ﭘـﺬﻳﺮد‬ ‫آﻪ ﻣﻲ ﺗﻮان ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ ﺗﺎرﻳﺦ و زﻣﺎن در ﺗﺎﺑﻊ )(‪ Format‬ﺑﻪ آﺎر ﺑﺮد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ date‬ﻧﻴﺰ ﺗﺎرﻳﺨﻲ اﺳﺖ آﻪ ﻗﺴﻤﺘﻲ از ﺁن ﺑﺎﻳﺪ اﺳﺘﺨﺮاج ﺷﻮد.‬ ‫ﺁرﮔﻮﻣـــﺎن هـــﺎي اﺧﺘﻴـــﺎري ‪ firstdayofweek‬و ‪ firstweekofyear‬ﻧﻴـــﺰ در ﺗـــﺎﺑﻊ )(‪DateDiff‬‬ ‫ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻧﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻓﺮض ﻣﻲ آﻨﻴﻢ ﺗﺎرﻳﺦ ﺟﺎري ﺳﻴﺴﺘﻢ، ٣٢ اآﺘﺒﺮ ﺳﺎل ١٠٠٢ ﻣﻴﻼدي اﺳﺖ.‬ ‫دﺳﺘﻮرات زﻳﺮ ﻧﺘﺎﻳﺞ ﻣﺨﺘﻠﻔﻲ را ﺑﻪ ﻣﺎ ﻧﺸﺎن ﻣﻲ دهﻨﺪ آﻪ ﻧﺘﻴﺠﻪ ﺑﻪ ﺻﻮرت ﭘﺮرﻧﮓ ﺗـﺮ ﻧﻤـﺎﻳﺶ دادﻩ‬ ‫ﺷﺪﻩ اﺳﺖ:‬ ‫‪Dim Day1 As DateTime‬‬ ‫)(‪day1 =Now‬‬ ‫))1‪Console.WriteLine(DatePart(“yyyy ”,day‬‬ ‫1002‬ ‫))1‪Console.WriteLine(DatePart(“q ”,day‬‬ ‫3‬ ‫))1‪Console.WriteLine(DatePart(“m ”,day‬‬ ‫01‬ ‫))1‪Console.WriteLine(DatePart(“d ”,day‬‬ ‫32‬ ‫))1‪Console.WriteLine(DatePart(“w ”,day‬‬ ‫3‬ ‫))1‪Console.WriteLine(DatePart(“ww ”,day‬‬ ‫34‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫١٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
Console.WriteLine(DatePart(“h ”,day1)) 15 Console.WriteLine(DatePart(“n ”,day1)) 3 Console.WriteLine(DatePart(“s ”,day1)) 30 ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ٤٢ Visual Basic.NET ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ‬
‫ﺗﻮاﺑﻌﻲ آﻪ ﺟﻬﺖ اﻧﺠﺎم ﻋﻤﻠﻴﺎت ورودي/ﺧﺮوﺟﻲ )‪ (I/O‬ﺑﺮ روي ﻓﺎﻳﻞ هﺎ ﻣﻮرد‬ ‫اﺳﺘﻔﺎدﻩ ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ )‪:(File I/O‬‬ ‫ﻳﻜﻲ از ﺟﻨﺒﻪ هﺎي ﻣﻬﻢ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ در هﺮ زﺑﺎن، ﻗﺎﺑﻠﻴﺖ دﺳﺘﺮﺳﻲ و ﻣـﺪﻳﺮﻳﺖ ﻓﺎﻳـﻞ هـﺎ ﻣـﻲ‬ ‫ﺑﺎﺷﺪ.‬ ‫در وﻳﮋوال ﺑﻴﺴﻴﻚ، ٣ ﻧﻮع ﻓﺎﻳﻞ وﺟﻮد دارد:‬ ‫١( ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ.‬ ‫٢( ﻓﺎﻳﻞ هﺎي ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ.‬ ‫٣( ﻓﺎﻳﻞ هﺎي ﺑﺎﻳﻨﺮي.‬ ‫ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ اﻏﻠﺐ ﻓﺎﻳـﻞ هـﺎي ﻣﺘﻨـﻲ )‪ (Text‬هـﺴﺘﻨﺪ. ﺑـﻪ ﻋﺒـﺎرت دﻳﮕـﺮ ﺷـﻤﺎ ﻣـﻲ ﺗﻮاﻧﻴـﺪ‬ ‫اﻳﻨﮕﻮﻧﻪ ﻓﺎﻳﻞ هﺎ را ﺑﺎ هﺮ وﻳﺮاﻳﺸﮕﺮ ﻣﺘﻨﻲ هﻤﺎﻧﻨﺪ ‪ Notepad‬ﺑﺎز آﻨﻴﺪ.‬ ‫در اﻳﻨﮕﻮﻧﻪ ﻓﺎﻳﻞ هﺎ هﺮ آﺎراآﺘﺮ ذﺧﻴﺮﻩ ﺷﺪﻩ در ﻓﺎﻳﻞ، ﻳﻚ ﺑﺎﻳﺖ را اﺷﻐﺎل ﻣﻲ آﻨﺪ.‬ ‫ﺗﻤﺎﻣﻲ اﻃﻼﻋﺎت ذﺧﻴﺮﻩ ﺷﺪﻩ در ﻓﺎﻳﻞ هﺎي ﻣﺘﻨﻲ ﺑﻪ ﺻﻮرت رﺷﺘﻪ اي ذﺧﻴﺮﻩ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫ﻣﺜﻼ ﻣﻘﺎدﻳﺮ ﻋﺪدي ﺑﻪ ﺻﻮرت ‪ Integer‬ﻳﺎ ‪ Double‬ذﺧﻴﺮﻩ ﻧﻤـﻲ ﺷـﻮﻧﺪ ﺑﻠﻜـﻪ ﺑـﻪ ﺻـﻮرت ‪String‬‬ ‫ﻋﻤﻞ ذﺧﻴﺮﻩ ﺳﺎزي ﺁﻧﻬﺎ اﻧﺠﺎم ﻣﻲ ﺷﻮد.‬ ‫ﻋﻤﻞ ﺧﻮاﻧﺪن ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ، ﺑﻪ ﺗﺮﺗﻴﺐ ﻳﻌﻨﻲ از اﺑﺘﺪا ﺗﺎ اﻧﺘﻬﺎي ﻓﺎﻳﻞ و ﺧﻂ ﺑﻪ ﺧـﻂ اﻧﺠـﺎم ﻣـﻲ‬ ‫ﺷﻮد ﺑﻨﺎﺑﺮاﻳﻦ ﺷﻤﺎ ﻧﻤﻲ ﺗﻮاﻧﻴﺪ در ﻳﻚ زﻣﺎن در ﻳـﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ هـﻢ اﻃﻼﻋـﺎت را ﺑﺨﻮاﻧﻴـﺪ و هـﻢ‬ ‫اﻃﻼﻋﺎت را ﺑﻨﻮﻳﺴﻴﺪ.‬ ‫اﮔﺮ ﻗﺼﺪ ﺧﻮاﻧـﺪن و ﻧﻮﺷـﺘﻦ هﻤﺰﻣـﺎن در و از ﻳـﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ را دارﻳـﺪ، ﺑﺎﻳـﺪ از دو ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ‬ ‫اﺳﺘﻔﺎدﻩ آﻨﻴﺪ. ﻳﻜﻲ ﺑﺮاي ﺧﻮاﻧﺪن اﻃﻼﻋﺎت و ﻳﻜﻲ ﺑﺮاي ﻧﻮﺷﺘﻦ اﻃﻼﻋﺎت درون ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ.‬ ‫اﮔﺮ در ﺑﺮﻧﺎﻣﻪ اي آﻪ ﻣﻲ ﻧﻮﻳﺴﻴﺪ ﺑﻪ ﻃﻮر ﻣﻜﺮر ﺑﺎ ﻓﺎﻳﻞ هـﺎ ﺳـﺮو آـﺎر دارﻳـﺪ ﺑـﻪ ﮔﻮﻧـﻪ اي آـﻪ ﺑﺎﻳـﺪ‬ ‫ﻣﺮﺗﺒﺎ ﻣﺤﺘﻮﻳﺎت ﻳﻚ ﻓﺎﻳﻞ ﺧﻮاﻧﺪﻩ ﺷﻮد و ﭘﺲ از اﻧﺠـﺎم ﺗﻐﻴﻴـﺮات ﻣﺠـﺪدا ذﺧﻴـﺮﻩ ﺷـﻮد، ﺑﺎﻳـﺪ از ﻓﺎﻳـﻞ‬ ‫هﺎي ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫اﻳﻦ ﻓﺎﻳﻞ هﺎ در ﻣﻘﺎﻳﺴﻪ ﺑﺎ ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ از ﺳﺮﻋﺖ ﺑﻴﺸﺘﺮي ﺑﺮﺧﻮردارﻧﺪ.‬ ‫ﻓﺎﻳﻞ هﺎي ﺗﺼﺎدﻓﻲ ﻧﻴﺰ هﻤﺎﻧﻨﺪ ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒـﻲ ﺑـﺮاي ﻣﻘـﺎدﻳﺮي از ﻧـﻮع رﺷـﺘﻪ اي ﺑـﻪ ازاي هـﺮ‬ ‫آﺎراآﺘﺮ، ﻳﻚ ﺑﺎﻳﺖ را اﺧﺘﺼﺎص ﻣﻲ دهﻨﺪ اﻣﺎ ﺑـﺮ ﺧـﻼف ﻓﺎﻳـﻞ هـﺎي ﺗﺮﺗﻴﺒـﻲ، در اﻳـﻦ ﻧـﻮع ﻓﺎﻳـﻞ هـﺎ‬ ‫ﻣﻘﺎدﻳﺮ ﻋﺪدي ﺑﺎ ﻧﻮع ﺧﺎص ﺧﻮد ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ ﻣﺜﻼ ‪ Integer‬ﻳﺎ ‪.Double‬‬ ‫ﺑﺮاي ﻧﻤﺎﻳﺶ ﻓﺎﻳـﻞ هـﺎي ﺗـﺼﺎدﻓﻲ در ﻣﺤـﻴﻂ ‪ Dos‬ﻣـﻲ ﺗﻮاﻧﻴـﺪ ﺑـﺎ ﻧﻮﺷـﺘﻦ دﺳـﺘﻮر ‪ TYPE‬در ﺧـﻂ‬ ‫ﻓﺮﻣﺎن، ﻣﻘﺎدﻳﺮ رﺷﺘﻪ اي ذﺧﻴﺮﻩ ﺷﺪﻩ در اﻳﻦ ﻓﺎﻳﻞ هﺎ را ﻣﺸﺎهﺪﻩ آﻨﻴـﺪ اﻣـﺎ ﻗـﺎدر ﺑـﻪ دﻳـﺪن اﻋـﺪاد‬ ‫ذﺧﻴﺮﻩ ﺷﺪﻩ ﻧﻴﺴﺘﻴﺪ.‬ ‫ﻓﺎﻳﻞ هﺎي ﺗﺼﺎدﻓﻲ ﺑﺮاي ذﺧﻴﺮﻩ آﺮدن دادﻩ هﺎﻳﻲ آـﻪ در ﺑﺨـﺶ هـﺎﻳﻲ ﺑـﺎ ﻃـﻮل ﻣـﺸﺨﺺ دﺳـﺘﻪ‬ ‫ﺑﻨﺪي ﺷﺪﻩ اﻧﺪ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ.‬ ‫اﻳﻦ ﺑﺨﺶ هﺎ را اﺻﻄﻼﺣﺎ رآﻮرد ﻣﻲ ﻧﺎﻣﻴﻢ.‬ ‫ﻓﺎﻳﻞ هﺎي ﺗﺼﺎدﻓﻲ ﺑﻪ ﺷﻤﺎ اﻳﻦ اﻣﻜﺎن را ﻣﻲ دهﻨﺪ آﻪ ﺑﻪ هﺮ رآﻮرد دﻟﺨـﻮاﻩ در ﻓﺎﻳـﻞ ﺑـﻪ ﺳـﺮﻋﺖ‬ ‫دﺳﺘﺮﺳﻲ داﺷﺘﻪ ﺑﺎﺷﻴﺪ.‬ ‫از ﺁﻧﺠﺎﻳﻲ آﻪ ﺗﻤﺎﻣﻲ رآﻮردهﺎ در ﻓﺎﻳﻞ ﺗﺼﺎدﻓﻲ داراي ﻃـﻮل ﺛـﺎﺑﺘﻲ هـﺴﺘﻨﺪ، اﺿـﺎﻓﻪ آـﺮدن رآـﻮرد‬ ‫ﺟﺪﻳﺪ در ﻓﺎﻳﻞ ﺑﺎ اﺧﺘﺼﺎص دادن ﻳﻚ ﺷﻤﺎرﻩ ﺷﺎﺧﺺ )‪ (index‬ﺑﻪ اﻳﻦ رآﻮرد ﺑﺴﻴﺎر ﺁﺳﺎن اﺳﺖ.‬ ‫ﻓﺎﻳﻞ هﺎي ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ ﺑﺮﺧﻼف ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ ﻣﻲ ﺗﻮاﻧﻨﺪ در ﻳﻚ زﻣـﺎن، هـﻢ ﻓﺎﻳـﻞ را‬ ‫ﺑﺨﻮاﻧﻨﺪ و هﻢ در ﺁن ﺑﻨﻮﻳﺴﻨﺪ.‬ ‫در ﻓﺎﻳﻞ هﺎي ﺗـﺼﺎدﻓﻲ اﻃﻼﻋـﺎت را ﻣـﻲ ﺗـﻮان در هـﺮ ﺟـﺎي ﻓﺎﻳـﻞ ﻧﻮﺷـﺖ ﺑـﺪون ﺁﻧﻜـﻪ هﻤﺠـﻮاري‬ ‫رآﻮردهﺎ از ﺑﻴﻦ ﺑﺮود ﻳﺎ ﻟﻄﻤﻪ اي ﺑﺨﻮرد.‬ ‫ﻓﺎﻳﻞ هﺎي ﺑﺎﻳﻨﺮي: اﻳﻨﮕﻮﻧﻪ ﻓﺎﻳﻞ هﺎ ﺷﺒﻴﻪ ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ هﺴﺘﻨﺪ.‬ ‫ﻣﺤﺘﻮﻳﺎت اﻳﻦ ﻓﺎﻳﻞ هﺎ ﻣﻲ ﺗﻮاﻧﺪ هﺮ ﭼﻴﺰي ﺑﺎﺷﺪ.‬ ‫آﺎراآﺘﺮ، ﻋﺪد ﻳﺎ ﺣﺘﻲ ﺗﺼﺎوﻳﺮ ﻣﻲ ﺗﻮاﻧﻨﺪ در ﻓﺎﻳﻞ هﺎي ﺑﺎﻳﻨﺮي ذﺧﻴﺮﻩ ﺷﻮﻧﺪ.‬ ‫در اﻳﻦ ﻧﻮع ﻓﺎﻳﻞ هﺎ، دادﻩ هﺎ ﺑﻪ ﺻﻮرت ﺑﺎﻳﻨﺮي ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫ﻣﺜﻼ ﻋﺪد ٦٢٤ ﻋﺪدي از ﻧﻮع ﺻﺤﻴﺢ اﺳﺖ و ﭼﻮن اﻋﺪاد ﺻﺤﻴﺢ دو ﺑﺎﻳﺖ از ﺣﺎﻓﻈـﻪ را اﺷـﻐﺎل ﻣـﻲ‬ ‫آﻨﻨﺪ ﭘﺲ ﻣﻴﺰان ﻓﻀﺎي اﺧﺘﺼﺎص ﻳﺎﻓﺘﻪ ﺑﻪ اﻳﻦ ﻋﺪد در اﻳﻦ ﻧﻮع ﻓﺎﻳﻞ، ٢ ﺑﺎﻳﺖ اﺳﺖ.‬ ‫اﻧﺠﺎم ﻋﻤﻠﻴﺎت ﺑﺮ روي ﻓﺎﻳﻞ هﺎ ﺑﺪون در ﻧﻈﺮ ﮔﺮﻓﺘﻦ ﻧﻮع ﺁﻧﻬﺎ، ﺑﻪ ﻃـﻮر آﻠـﻲ ﺷـﺎﻣﻞ ٣ ﻣﺮﺣﻠـﻪ ﻣـﻲ‬ ‫ﺑﺎﺷﺪ:‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٣٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﺑﺎزآﺮدن ﻓﺎﻳﻞ: در اﻳﻦ ﻣﺮﺣﻠﻪ، ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﻣﻴـﺰان ﻣﻌﻴﻨـﻲ از ﺣﺎﻓﻈـﻪ را ﺑـﺮاي ﻧﮕﻬـﺪاري دادﻩ‬ ‫هﺎي ﻓﺎﻳﻞ آﻨﺎر ﻣﻲ ﮔﺬارد. اﮔﺮ ﻓﺎﻳﻞ وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ، اﺑﺘـﺪا ﺳـﺎﺧﺘﻪ ﺷـﺪﻩ و ﺳـﭙﺲ ﺑـﺎز ﻣـﻲ‬ ‫ﺷﻮد.‬ ‫ﺑﺮاي ﺑﺎزآﺮدن ﻳﺎ در ﺻﻮرت ﻟﺰوم، اﻳﺠﺎد ﻳﻚ ﻓﺎﻳﻞ از ﺗﺎﺑﻊ )(‪ FileOpen‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﭘﺮدازش ﻓﺎﻳﻞ: ﻳﻚ ﻓﺎﻳﻞ ﻣﻲ ﺗﻮاﻧـﺪ ﺑـﺮاي ﺧﻮاﻧـﺪن، ﻧﻮﺷـﺘﻦ و ﻳـﺎ ﺧﻮاﻧـﺪن-ﻧﻮﺷـﺘﻦ هﻤﺰﻣـﺎن دادﻩ‬ ‫هﺎﻳﺶ ﺑﺎز ﺷﻮد.‬ ‫دادﻩ هﺎﻳﻲ آﻪ ﺧﻮاﻧﺪﻩ ﻣﻲ ﺷﻮﻧﺪ، ﭘﺮدازش ﺷﺪﻩ و ﺳﭙﺲ در هﻤﺎن ﺟﺎي ﻗﺒﻠﻲ ﻳﺎ در ﻓﺎﻳﻞ دﻳﮕﺮي‬ ‫ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫ﺑﺴﺘﻦ ﻓﺎﻳﻞ: هﻨﮕﺎﻣﻲ آﻪ آﺎر ﺑﺎ ﻓﺎﻳﻞ ﺑﻪ اﺗﻤﺎم رﺳﻴﺪ ﺑﺎﻳﺪ ﺁن را ﺑﺴﺖ. هﻨﮕﺎﻣﻲ آﻪ ﻓﺎﻳـﻞ ﺑـﺴﺘﻪ‬ ‫ﺷﺪ، ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﻓﻀﺎي اﺧﺘﺼﺎص دادﻩ ﺷﺪﻩ ﺑﻪ ﻓﺎﻳﻞ را ﺑﻪ ﺣﺎﻓﻈﻪ اﺻﻠﻲ ﺑﺎز ﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺑﺮاي ﺑﺴﺘﻦ ﻳﻚ ﻓﺎﻳﻞ ﺑﺎز از ﺗﺎﺑﻊ )(‪ FileClose‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫)‪FreeFile(file_number‬‬ ‫هﺮ ﻓﺎﻳﻠﻲ آﻪ ﺑﺎز ﻣﻲ ﺷﻮد ﺑﺎﻳﺪ ﺷﻤﺎرﻩ اي ﺑﻪ ﺁن اﺧﺘﺼﺎص ﻳﺎﺑﺪ.‬ ‫اﮔﺮ ﺑﺮﻧﺎﻣﻪ ي ﺷﻤﺎ در ﻃﻮل دورﻩ آﺎري ﺧﻮد ﺗﻌﺪاد زﻳـﺎدي ﻓﺎﻳـﻞ را ﺑـﺎز ﻳـﺎ ﺑـﺴﺘﻪ ﻣـﻲ آﻨـﺪ، ﻣﻤﻜـﻦ‬ ‫ﻧﻴﺴﺖ آﻪ ﺷﻤﺎ هﻤﻴﺸﻪ ﺷﻤﺎرﻩ ﻓﺎﻳﻞ ﻳﺎ ﻓﺎﻳﻞ هﺎﻳﻲ را آﻪ هﻢ اآﻨﻮن ﺑﺎز هﺴﺘﻨﺪ ﺑﺪاﻧﻴﺪ.‬ ‫در ‪ ،VB‬ﺗﺎﺑﻊ )(‪ FreeFile‬ﺷﻤﺎرﻩ ﻓﺎﻳﻠﻲ ﺑﻌﺪي را آﻪ ﻗﺮار اﺳﺖ ﺑﺎز ﺷﻮد ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ هﻤﻴﺸﻪ ﺑﺎ ﺗﺎﺑﻊ )(‪ FileOpen‬ﺟﻬﺖ ﺑﺎزآﺮدن ﻳﻚ ﻓﺎﻳﻞ ﺑﻪ آﺎر ﻣﻲ رود.‬ ‫ﻧﻜﺘﻪ: ﺗﺎﺑﻊ )(‪ FreeFile‬را ﻧﻤﻲ ﺗﻮان ﺑﻪ ﻃﻮر ﻣﺴﺘﻘﻴﻢ در ﺗﺎﺑﻊ )(‪ OpenFile‬ﺑﻪ آﺎر ﺑﺮد.‬ ‫دﺳﺘﻮر زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)‪FileOpen(FreeFile(), ”C:MyFile.dat”,OpenMode.Input‬‬ ‫اﻳﻦ دﺳﺘﻮر از ﻧﻈﺮ ﻧﺤﻮي درﺳﺖ آﺎر ﻣﻲ آﻨﺪ اﻣﺎ ﺷﻤﺎرﻩ ﻓﺎﻳﻞ را در اﺧﺘﻴﺎرﺗـﺎن ﻗـﺮار ﻧﻤـﻲ دهـﺪ ﺗـﺎ‬ ‫ﺑﺘﻮاﻧﻴﺪ اﻋﻤﺎل ﺧﻮاﻧﺪن ﻳﺎ ﻧﻮﺷﺘﻦ را ﺑﺮ روي ﻓﺎﻳﻞ اﻧﺠﺎم دهﻴﺪ.‬ ‫دﺳﺘﻮر زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)(‪fNum =FreeFile‬‬ ‫)‪FileOpen(fNum, fileName‬‬ ‫ﺑﻌﺪ از اﺟﺮاي اﻳﻦ دو دﺳﺘﻮر، هﺮ ﻓﺮﻣﺎﻧﻲ آﻪ ﺑﺎ ﻓﺎﻳﻞ ﺳﺮوآﺎر داﺷﺘﻪ ﺑﺎﺷﺪ ﻣﻲ ﺗﻮاﻧﺪ ﺑـﺎ ﺁوردن ﻧـﺎم‬ ‫‪ fNum‬در ﺁرﮔﻮﻣﺎن ﻣﺮﺑﻮﻃﻪ ي ﺧﻮد، ﺑﻪ اﻳﻦ ﻓﺎﻳﻞ دﺳﺘﺮﺳﻲ داﺷﺘﻪ ﺑﺎﺷﺪ.‬ ‫هﻤﺎن ﻃﻮر آﻪ ﮔﻔﺘﻪ ﺷﺪ اﻳﻦ ﺗﺎﺑﻊ، ﺷﻤﺎرﻩ ﻓﺎﻳﻞ ﺑﻌﺪي را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ ﻣﮕﺮ اﻳﻨﻜﻪ اﻳﻦ ﺷﻤﺎرﻩ ﺑـﻪ‬ ‫ﻓﺎﻳﻠﻲ اﺧﺘﺼﺎص دادﻩ ﺷﺪﻩ ﺑﺎﺷﺪ. در اﻳﻨﺼﻮرت در ﺻﻮرت ﻓﺮاﺧﻮاﻧﻲ ﻣﺠﺪد اﻳﻦ ﺗﺎﺑﻊ، ﻋﺪدي ﻣﺸﺎﺑﻪ‬ ‫ﻓﺮاﺧﻮاﻧﻲ ﻗﺒﻠﻲ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل دﺳﺘﻮرات زﻳﺮ آﺎر ﻧﻤﻲ آﻨﻨﺪ:‬ ‫)(‪fNum1 =FreeFile‬‬ ‫)(‪fNum2 =FreeFile‬‬ ‫)1‪FileOpen(fNum1, file‬‬ ‫)2‪FileOpen(fNum2, file‬‬ ‫دﺳﺘﻮر دوم اﺷﺘﺒﺎﻩ اﺳﺖ ﭼﻮن هﺮ وﻗﺖ آـﻪ ﺗـﺎﺑﻊ )(‪ FreeFile‬ﺑـﺮاي ﺗﻌﻴـﻴﻦ ﺷـﻤﺎرﻩ ي ﻳـﻚ ﻓﺎﻳـﻞ‬ ‫ﺟﺪﻳﺪ ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ ﺷﻮد ﺑﺎﻳﺪ ﻣﻮرد اﺳﺘﻔﺎدﻩ ﻗﺮار ﺑﮕﻴﺮد و ﻧﻤﻲ ﺗﻮان ﻗﺒﻞ از ﺑﻪ آﺎرﮔﻴﺮي ﺁن دوﺑﺎرﻩ‬ ‫از هﻤﻴﻦ ﺗﺎﺑﻊ ﺟﻬﺖ اﻳﺠﺎد ﻳﻚ ﺷﻤﺎرﻩ ﺟﺪﻳﺪ اﺳﺘﻔﺎدﻩ آﺮد.‬ ‫ﭘﺲ دﺳﺘﻮرات ﻓﻮق را ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺻﻼح ﻣﻲ آﻨﻴﻢ:‬ ‫)(‪fNum1 =FreeFile‬‬ ‫)1‪FileOpen(fNum1, file‬‬ ‫)(‪fNum2 =FreeFile‬‬ ‫)2‪FileOpen(fNum, file‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٤٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)] ‪FileOpen(number,path,mode [,access ][,share ][,recordLen‬‬ ‫ﺑﺮاي اﺳﺘﻔﺎدﻩ از ﻳﻚ ﻓﺎﻳﻞ، ﺑﺎﻳﺪ اﺑﺘﺪا ﺁن را ﺑﺎز ﻳﺎ در ﺻﻮرت ﻧﻴﺎز ﺁن را اﻳﺠﺎد آﻨﻴﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ FileOpen‬ﺑﺎ درﻳﺎﻓﺖ ﻣﻘﺎدﻳﺮي اﻳﻦ آﺎر را ﺑﺮاي ﺷﻤﺎ اﻧﺠﺎم ﻣﻲ دهﺪ.‬ ‫اﻳﻦ ﺗـﺎﺑﻊ، ﺟﺎﻧـﺸﻴﻦ دﺳـﺘﻮر ‪ Open‬در 0.6.‪ VB‬ﺷـﺪﻩ اﺳـﺖ. ﺗﻮﺟـﻪ داﺷـﺘﻪ ﺑﺎﺷـﻴﺪ آـﻪ دﺳـﺘﻮر‬ ‫‪ Open‬در ‪ VB.NET‬ﻗﺎﺑﻞ اﺳﺘﻔﺎدﻩ ﻧﻴﺴﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ path‬ﻣﺴﻴﺮ و ﻧﺎم ﻓﺎﻳﻠﻲ اﺳﺖ آﻪ ﺑﺎﻳﺪ ﺑﺎز ﺷﻮد و ﺁرﮔﻮﻣﺎن ‪ number‬ﺷـﻤﺎرﻩ اي اﺳـﺖ‬ ‫آﻪ ﺷﻤﺎ ﺑﻪ اﻳﻦ ﻓﺎﻳﻞ اﺧﺘﺼﺎص ﻣﻲ دهﻴﺪ )ﻣﻌﻤﻮﻻ ﺑﺎ ﺗﺎﺑﻊ )(‪.(FreeFile‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،mode‬ﻧﻮع ﻋﻤﻠﻴﺎﺗﻲ را آﻪ ﻗﺮار اﺳﺖ ﺑﺮ روي ﻓﺎﻳﻞ اﻧﺠﺎم ﺷـﻮد ﺗﻌﻴـﻴﻦ ﻣـﻲ آﻨـﺪ و ﻣـﻲ‬ ‫ﺗﻮاﻧﺪ ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ زﻳﺮ ﺑﺎﺷﺪ:‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ Mode‬در ﺗﺎﺑﻊ )(‪FileOpen‬‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻣﻘﺪار‬ ‫اﻳﻦ ﻣﻘﺪار ﺑﺮاي ﺑﺎزآﺮدن ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ آﻪ وﺟﻮد دارد ﺑﻪ آﺎر ﻣﻲ رود. اﮔﺮ ﻓﺎﻳـﻞ را ﺑـﺎ‬ ‫‪Input‬‬ ‫اﻳﻦ ﻣﻘﺪار ﺑﺎز آﻨﻴﻢ ﻓﻘﻂ ﻣﻲ ﺗﻮاﻧﻴﻢ اﻃﻼﻋﺎت را از ﺁن ﺑﺨﻮاﻧﻴﻢ. ﭼﻨﺎﻧﭽـﻪ ﻓـﺎﻳﻠﻲ آـﻪ‬ ‫ﻗﺒﻼ ﺑﺮ روي دﻳﺴﻚ وﺟـﻮد ﻧﺪاﺷـﺘﻪ و ﺑﺨـﻮاهﻴﻢ ﺑـﺎ ﻣـﺪ ‪ Input‬ﺑـﺎز آﻨـﻴﻢ، ﺧﻄـﺎﻳﻲ‬ ‫اﺗﻔﺎق ﻣﻲ اﻓﺘﺪ.‬ ‫اﻳ ـﻦ ﻣﻘ ـﺪار، ﻓﺎﻳ ـﻞ ﺗﺮﺗﻴﺒ ـﻲ را ﻃ ـﻮري ﺑ ـﺎز ﻣ ـﻲ آﻨ ـﺪ آ ـﻪ ﺑﺘ ـﻮان اﻃﻼﻋ ـﺎﺗﻲ را در ﺁن‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫‪Output‬‬ ‫ﻧﻮﺷﺖ. اﮔﺮ ﻓﺎﻳﻠﻲ آﻪ ﺑﺎ ﻣﺪ ‪ Output‬ﺑـﺎز ﻣـﻲ ﺷـﻮد وﺟـﻮد ﻧﺪاﺷـﺘﻪ ﺑﺎﺷـﺪ، ﺁن را‬ ‫اﻳﺠﺎد ﻣﻲ آﻨﺪ وﻟﻲ اﮔﺮ وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﺪ، اﻃﻼﻋﺎت ﻗﺒﻠﻲ ﺁن را از ﺑـﻴﻦ ﻣـﻲ ﺑـﺮد‬ ‫و ﺁن را ﺑﺮاي درﻳﺎﻓﺖ اﻃﻼﻋﺎت ﺟﺪﻳﺪ ﺁﻣﺎدﻩ ﻣﻲ آﻨﺪ. ﺑﻪ ﻃﻮر آﻠﻲ اﻳـﻦ ﻣﻘـﺪار ﻓﺎﻳـﻞ‬ ‫را در ﺣﺎﻟﺖ ﺧﺮوﺟﻲ ﺑﺎز ﻣﻲ آﻨﺪ ﻳﻌﻨﻲ ﻓﻘﻂ ﻣﻲ ﺗﻮان اﻃﻼﻋﺎت را ﺑـﻪ ﻓﺎﻳـﻞ اﺿـﺎﻓﻪ‬ ‫آﺮد.‬ ‫ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ آﻪ ﻗﺒﻼ وﺟـﻮد داﺷـﺘﻪ ﺑﺎﺷـﺪ و ﺑﺨـﻮاهﻴﻢ اﻃﻼﻋـﺎﺗﻲ زا ﺑـﻪ ﺁن اﺿـﺎﻓﻪ‬ ‫‪Append‬‬ ‫آﻨﻴﻢ، ﺑﺎﻳﺪ از اﻳﻦ ﻣﻘﺪار اﺳﺘﻔﺎدﻩ آﻨﻴﻢ. ﭼﻨﺎﻧﭽﻪ ﻓﺎﻳﻞ ﻗﺒﻼ وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷـﺪ، ﺁن‬ ‫را اﻳﺠﺎد ﻣﻲ آﻨﺪ.‬ ‫اﻳﻦ ﻣﻘﺪار، ﻓﺎﻳﻞ را ﺑﻪ ﺻﻮرت ﺑﺎﻳﻨﺮي ﺑﺎز ﻣﻲ آﻨﺪ. در ﺣﺎﻟﺖ ﺑﺎﻳﻨﺮي ﻣﻲ ﺗﻮان ﺑﻪ هـﺮ‬ ‫‪Binary‬‬ ‫ﻳﻚ از ﺑﺎﻳﺖ هﺎي ﻓﺎﻳﻞ دﺳﺘﺮﺳﻲ داﺷﺖ و ﻣﻲ ﺗﻮان ﻳﻚ ﺑﺎﻳﺖ را از ﻓﺎﻳـﻞ ﺧﻮاﻧـﺪ ﻳـﺎ‬ ‫در ﻓﺎﻳﻞ ﻧﻮﺷﺖ.‬ ‫اﻳﻦ ﻣﻘﺪار، ﻳﻚ ﻓﺎﻳﻞ را ﺑﻪ ﻃﻮر ﺗﺼﺎدﻓﻲ ﺑﺎز ﻣـﻲ آﻨـﺪ. در اﻳـﻦ ﺣﺎﻟـﺖ ﻣـﻲ ﺗـﻮان در‬ ‫‪Random‬‬ ‫ﻓﺎﻳﻞ ﻧﻮﺷﺖ ﻳﺎ از ﻓﺎﻳﻞ ﺧﻮاﻧﺪ.‬ ‫ﺳﻪ ﻣﻘﺪار اول ﺑﺎ ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒـﻲ، ﻣﻘـﺪار ‪ Random‬ﺑـﺎ ﻓﺎﻳـﻞ هـﺎي ﺑـﺎ دﺳﺘﺮﺳـﻲ ﺗـﺼﺎدﻓﻲ و‬ ‫ﻣﻘﺪار ‪ Binary‬ﺑﺮاي ﻓﺎﻳﻞ هﺎي ﺑﺎﻳﻨﺮي ﺑﻪ آﺎر ﻣﻲ روﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ access‬ﻧﻮع دﺳﺘﺮﺳﻲ ﺑﻪ ﻓﺎﻳﻞ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ. ﻳﻌﻨﻲ ﻓﺎﻳﻞ ﺑﺮاي ﺧﻮاﻧـﺪن ﻳـﺎ‬ ‫ﻧﻮﺷﺘﻦ ﻳﺎ هﺮ دو ﻋﻤﻞ ﺑﺎز ﺷﻮد.‬ ‫ﻣﻘﺎدﻳﺮي آﻪ اﻳﻦ ﺁرﮔﻮﻣﺎن ﻣﻲ ﺗﻮاﻧﺪ ﺑﭙﺬﻳﺮد در ﺟﺪول زﻳﺮ ﺁﻣﺪﻩ اﺳﺖ:‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ access‬در ﺗﺎﺑﻊ )(‪FileOpen‬‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻣﻘﺪار‬ ‫ﻓﺎﻳﻞ را در ﺣﺎﻟﺖ ورودي ﺑﺎز ﻣﻲ آﻨﺪ. ﻳﻌﻨﻲ ﻓﻘﻂ ﻣﻲ ﺗﻮان ﻓﺎﻳﻞ را ﺧﻮاﻧﺪ.‬ ‫‪Read‬‬ ‫ﻓﺎﻳﻞ را در ﺧﺎﻟﺖ ﺧﺮوﺟﻲ ﺑﺎز ﻣﻲ آﻨﺪ. ﻳﻌﻨﻲ ﻓﻘﻂ ﻣﻲ ﺗﻮان در ﻓﺎﻳﻞ ﻧﻮﺷﺖ.‬ ‫‪Write‬‬ ‫ﻓﺎﻳﻞ را در ﺣﺎﻟﺖ ورودي-ﺧﺮوﺟﻲ ﺑﺎز ﻣﻲ آﻨﺪ. ﻳﻌﻨﻲ هﻢ ﻣﻲ ﺗﻮان اﻃﻼﻋـﺎت را‬ ‫‪ReadWrite‬‬ ‫از ﻓﺎﻳﻞ ﺧﻮاﻧﺪ و هﻢ در ﻓﺎﻳﻞ ﻧﻮﺷﺖ.‬ ‫اﻳﻦ ﺁرﮔﻮﻣﺎن ﺑﻴـﺸﺘﺮ ﺑـﺮاي ﺑـﺎﻻ ﺑـﺮدن اﻣﻨﻴـﺖ آـﺎر ﺑـﺎ ﻓﺎﻳـﻞ ﺑـﻪ آـﺎر ﻣـﻲ رود و ﺿـﺮورت ﭼﻨـﺪاﻧﻲ در‬ ‫اﺳﺘﻔﺎدﻩ از ﺁن وﺟﻮد ﻧﺪارد. ﻣﺜﻼ ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ ﻣﻲ ﺗﻮاﻧﻨﺪ ﺑﺮاي ﻓﻘﻂ ﺧﻮاﻧـﺪن ﻳـﺎ ﻓﻘـﻂ ﻧﻮﺷـﺘﻦ‬ ‫ﺑﺎز ﺷﻮﻧﺪ ﻧﻪ هﺮ دو. ﭘﺲ اﺳﺘﻔﺎدﻩ از ﺁرﮔﻮﻣﺎن ‪ ReadWrite‬اﻳﻦ ﺁرﮔﻮﻣـﺎن در هﻨﮕـﺎم ﺑـﺎز آـﺮدن ﻳـﻚ‬ ‫ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ ﺑﻲ اﺛﺮ اﺳﺖ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٥٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫وﻟﻲ ﺟﻬﺖ ﺑﺎﻻ ﺑﺮدن ﺿﺮﻳﺐ اﻣﻨﻴﺖ اﺳﺘﻔﺎدﻩ از ﻓﺎﻳﻞ، هﻨﮕﺎﻣﻲ آﻪ ﻓﺎﻳـﻞ را در هـﺮ ﺣـﺎﻟﺘﻲ ﺑـﺎز ﻣـﻲ‬ ‫آﻨﻴﺪ، ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻧﻮع ﻓﺎﻳﻞ اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺁرﮔﻮﻣﺎن ﻧﻴﺰ ﺿﺮري ﻧﺪارد.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،share‬ﻧﺤﻮﻩ ﻋﻜﺲ اﻟﻌﻤﻞ ﻓﺎﻳﻠﻲ آﻪ ﺗﻮﺳﻂ ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﺑﺎز ﺷﺪﻩ اﺳـﺖ را ﺑـﻪ‬ ‫ﺑﺮﻧﺎﻣﻪ هﺎي دﻳﮕﺮ وﻳﻨﺪوز، در هﻤﺎن زﻣﺎن آﻪ ﺷﻤﺎ ﻓﺎﻳﻞ را ﺑﺎز آﺮدﻩ اﻳﺪ ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ.‬ ‫ﺑﻪ ﻋﺒﺎرت دﻳﮕﺮ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻧﺤﻮﻩ دﺳﺘﺮﺳﻲ ﺑﺮﻧﺎﻣﻪ هﺎي دﻳﮕﺮ را ﺑﻪ ﻓﺎﻳﻠﻲ آﻪ ﺷﻤﺎ ﺑـﺎز آـﺮدﻩ‬ ‫و در ﺣﺎل اﺳﺘﻔﺎدﻩ از ﺁن هﺴﺘﻴﺪ ﺗﻌﻴﻴﻦ آﻨﻴﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ share‬ﻣﻲ ﺗﻮاﻧﺪ ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ زﻳﺮ را ﺑﭙﺬﻳﺮد:‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ share‬در ﺗﺎﺑﻊ )(‪FileOpen‬‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻣﻘﺪار‬ ‫ﺑﺮﻧﺎﻣﻪ هﺎي دﻳﮕﺮ ﻣﻲ ﺗﻮاﻧﻨﺪ از ﻓﺎﻳﻞ اﺳﺘﻔﺎدﻩ آﻨﻨﺪ.‬ ‫‪Shared‬‬ ‫ﺑﺮﻧﺎﻣﻪ هﺎي دﻳﮕﺮ ﻓﻘﻂ در ﺻﻮرﺗﻲ ﻣﺠﺎز ﺑﻪ اﺳﺘﻔﺎدﻩ از ﻓﺎﻳﻞ هـﺴﺘﻨﺪ آـﻪ‬ ‫‪LockRead‬‬ ‫ﺁن را ﻓﻘﻂ ﺑﺮاي ﺧﻮاﻧﺪن ﺑﺎز آﺮدﻩ ﺑﺎﺷﻨﺪ.‬ ‫ﺑﺮﻧﺎﻣﻪ هﺎي دﻳﮕﺮ ﻓﻘﻂ در ﺻﻮرﺗﻲ ﻣﺠﺎز ﺑﻪ اﺳﺘﻔﺎدﻩ از ﻓﺎﻳﻞ هـﺴﺘﻨﺪ آـﻪ‬ ‫‪LockWrite‬‬ ‫ﺁن را ﻓﻘﻂ ﺑﺮاي ﻧﻮﺷﺘﻦ ﺑﺎز آﺮدﻩ ﺑﺎﺷﻨﺪ.‬ ‫ﺑﺮﻧﺎﻣﻪ هﺎي دﻳﮕﺮ ﻣﺠﺎز ﺑﻪ اﺳﺘﻔﺎدﻩ از ﻓﺎﻳﻞ ﻧﻴﺴﺘﻨﺪ‬ ‫‪LockReadWrite‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ share‬ﻳﻚ ﭘﺎراﻣﺘﺮ ﺑﺴﻴﺎر ﻣﻬﻢ ﺑﺮاي ﺑﺮﻧﺎﻣﻪ هـﺎﻳﻲ اﺳـﺖ آـﻪ ﺗﺤـﺖ ﺷـﺒﻜﻪ ﻧﻮﺷـﺘﻪ ﻣـﻲ‬ ‫ﺷﻮﻧﺪ. ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل دو آﺎرﺑﺮ ﺑﻪ ﻃﻮر هﻤﺰﻣﺎن ﻗﺼﺪ ﻧﻮﺷﺘﻦ در ﻳﻚ ﻓﺎﻳﻞ را دارﻧﺪ.‬ ‫و اﻣﺎ ﺁﺧﺮﻳﻦ ﺁرﮔﻮﻣﺎن ﻳﻌﻨﻲ ﺁرﮔﻮﻣﺎن اﺧﺘﻴـﺎري ‪ recordlen‬آـﻪ ﻓﻘـﻂ در ﻓﺎﻳـﻞ هـﺎي ﺑـﺎ دﺳﺘﺮﺳـﻲ‬ ‫ﺗﺼﺎدﻓﻲ آﺎرﺑﺮد دارد.‬ ‫اﮔﺮ ﻓﺎﻳﻠﻲ آﻪ ﻗﺼﺪ ﺑﺎزآﺮدن ﺁن را دارﻳﺪ از اﻳﻦ ﻧﻮع ﺑﺎﺷﺪ ﺑﺎﻳﺪ ﻃﻮل هﺮ رآﻮرد ﻓﺎﻳﻞ را آﻪ ﺑـﺮ ﺣـﺴﺐ‬ ‫ﺑﺎﻳﺖ اﺳﺖ ﺑﻪ وﺳﻴﻠﻪ اﻳﻦ ﺁرﮔﻮﻣﺎن ﻣﺸﺨﺺ آﻨﻴﺪ.‬ ‫هﻨﮕﺎﻣﻲ آﻪ در وﻳﮋوال ﺑﻴﺴﻴﻚ ﻓﺎﻳﻠﻲ ﺑﺎ دﺳﺘﺮﺳـﻲ ﺗـﺼﺎدﻓﻲ اﻳﺠـﺎد ﻣـﻲ آﻨﻴـﺪ، هـﻴﭻ اﻃﻼﻋـﺎﺗﻲ‬ ‫راﺟﻊ ﺑﻪ ﻃﻮل رآﻮرد ﻳﺎ ﺳﺎﺧﺘﺎر ﺁن در ﻓﺎﻳﻞ ذﺧﻴﺮﻩ ﻧﻤﻲ ﺷﻮد.‬ ‫اﻳﻦ ﻣﻮرد را ﻗﺒﻞ از ﺑﺎزآﺮدن اﻳﻦ ﻧﻮع ﻓﺎﻳﻞ هﺎ ﺑﺎﻳﺪ ﺑﺪاﻧﻴﺪ.‬ ‫ﻃـﻮل رآـﻮرد، ﻣﺠﻤـﻮع ﺑﺎﻳـﺖ هـﺎي ﺗﻤـﺎﻣﻲ ﻓﻴﻠـﺪهﺎي ﺁن ﻓﺎﻳـﻞ اﺳـﺖ آـﻪ ﻣـﻲ ﺗﻮاﻧﻴـﺪ ﺑـﺎ دﺳـﺘﻮر‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫)‪ Len(record‬ﺁن را ﻣﺤﺎﺳﺒﻪ آﻨﻴﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ record‬در اﻳﻦ دﺳﺘﻮر ﻧﺎم ﺳﺎﺧﺘﺎري اﺳﺖ آﻪ ﺑﺮاي ﺑﺎزآﺮدن ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ ﺑـﻪ آـﺎر ﺑـﺮدﻩ‬ ‫اﻳﺪ.‬ ‫دﺳﺘﻮر زﻳﺮ ﻓﺎﻳﻞ ‪ C:samplesvbcust.dat‬را آﻪ ﻳـﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ اﺳـﺖ ﺑـﺎ اﺧﺘـﺼﺎص دادن‬ ‫ﻋﺪدي آﻪ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ FreeFile‬ﺑﻪ دﺳﺖ ﺁوردﻩ، در ﺣﺎﻟﺖ ورودي-ﺧﺮوﺟﻲ ﺑﺎز ﻣﻲ آﻨﺪ:‬ ‫)(‪Dim Fnum As Integer =FreeFile‬‬ ‫)‪FileOpen(Fnum, “c:samples vb cust.dat ”, OpenMode.Output, OpenAccess.ReadWrite‬‬ ‫)‪FileClose(file_number‬‬ ‫ﭘﺲ از اﻳﻨﻜﻪ آﺎر ﺑﺎ ﻓﺎﻳﻞ ﺗﻤﺎم ﺷﺪ، ﺑﺎﻳﺪ ﺁن را ﺑﺴﺖ.‬ ‫ﺗﺎﺑﻊ )(‪ FileClose‬ﻓﺎﻳﻠﻲ را آـﻪ ﺷـﻤﺎرﻩ ي ﺁن ﺑـﻪ وﺳـﻴﻠﻪ ي ﺁرﮔﻮﻣـﺎن ‪ file_number‬ﻣـﺸﺨﺺ‬ ‫ﺷﺪﻩ ﻣﻲ ﺑﻨﺪد.‬ ‫دﺳﺘﻮر زﻳﺮ، ﻓﺎﻳﻠﻲ را آﻪ ﺷﻤﺎرﻩ ي ﺁن در ﻋﺒﺎرت 1‪ fNum‬وﺟﻮد دارد ﻣﻲ ﺑﻨﺪد.‬ ‫)1‪FileClose(fNum‬‬ ‫)(‪Reset‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ در ﺣﻘﻴﻘﺖ آﺎر ﺷﻤﺎ را در ﺑﺴﺘﻦ ﻓﺎﻳﻞ هﺎ ﺑﺴﻴﺎر ﺁﺳﺎﻧﺘﺮ ﻣﻲ آﻨﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﻤﺎﻣﻲ ﻓﺎﻳﻞ هﺎﻳﻲ را آﻪ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ FileOpen‬در ﺑﺮﻧﺎﻣـﻪ ﺷـﻤﺎ ﺑـﺎز ﺷـﺪﻩ اﻧـﺪ‬ ‫ﻣﻲ ﺑﻨﺪد.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٦٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)‪EOF(file_number) , LOF(file_number‬‬ ‫اﻳﻦ دو ﺗﺎﺑﻊ ﻣﻌﻤﻮﻻ در ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ ﻓﺎﻳﻞ هﺎ ﺳﺮ و آﺎر دارﻧﺪ ﺑﺴﻴﺎر ﺑﻪ آﺎر ﻣﻲ روﻧﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ EOF‬ﺑﺮاي ﺗﺴﺖ ﺷﺮط ﭘﺎﻳﺎن ﻓﺎﻳﻞ ﺑﻪ آـﺎر ﻣـﻲ رود. اﻳـﻦ ﺗـﺎﺑﻊ ﻓـﺎﻳﻠﻲ را آـﻪ ﺷـﻤﺎرﻩ ﺁن ﺑـﻪ‬ ‫وﺳﻴﻠﻪ ﺁرﮔﻮﻣﺎن ‪ file_number‬ﻣﺸﺨﺺ ﺷﺪﻩ ﭼﻚ ﻣﻲ آﻨﺪ و ﭼﻨﺎﻧﭽﻪ اﺷﺎرﻩ ﮔﺮ ﻓﺎﻳﻞ ﺑﻪ اﻧﺘﻬـﺎي‬ ‫ﺁن رﺳﻴﺪﻩ ﺑﺎﺷﺪ، اﻳﻦ ﺗﺎﺑﻊ ﻣﻘﺪار ‪ True‬وﮔﺮﻧﻪ ﻣﻘﺪار ‪ False‬را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ ،LOF‬اﻧﺪازﻩ ﻳﻚ ﻓﺎﻳﻞ ﺑﺎز را آـﻪ ﺷـﻤﺎرﻩ ﺁن ﺑـﻪ وﺳـﻴﻠﻪ ﺁرﮔﻮﻣـﺎن ‪ file_number‬ﻣـﺸﺨﺺ‬ ‫ﺷﺪﻩ اﺳﺖ ﺑﺮ ﺣﺴﺐ ﺑﺎﻳﺖ ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺷﺒﻪ آﺪ زﻳﺮ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ EOF‬و ﻳﻚ ﺣﻠﻘﻪ ﺗﻜﺮار، ﭘﺎﻳﺎن ﻳﻚ ﻓﺎﻳﻞ را ﭼﻚ ﻣﻲ آﻨﺪ:‬ ‫}رﻓﺘﻦ ﺑﻪ اوﻟﻴﻦ رآﻮرد ﻓﺎﻳﻞ{‬ ‫)‪While Not EOF(fNum‬‬ ‫}ﭘﺮدازش رآﻮرد ﺟﺎري{‬ ‫}رﻓﺘﻦ ﺑﻪ رآﻮرد ﺑﻌﺪ{‬ ‫‪End While‬‬ ‫ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ LOF‬ﻗﺎدر ﺑﻪ ﻣﺤﺎﺳﺒﻪ ي ﺗﻌﺪاد رآﻮرد هﺎي ﻳﻚ ﻓﺎﻳﻞ ﺑﺎ دﺳﺘﺮﺳـﻲ ﺗـﺼﺎدﻓﻲ‬ ‫هﺴﺘﻴﺪ. دﺳﺘﻮر زﻳﺮ اﻳﻦ آﺎر را ﺑﺮاي ﻣﺎ اﻧﺠﺎم ﻣﻲ دهﺪ:‬ ‫)‪Rec_Length =LOF(file_number) / Len(record‬‬ ‫)‪Print (file_number,output_list) , PrintLine(file_number,output_list‬‬ ‫ﺑﺮاي ﻧﻮﺷﺘﻦ در ﻳﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ آـﻪ ﺑـﻪ ﺻـﻮرت ‪ Output‬ﻳـﺎ ‪ Append‬ﺑـﺎز ﺷـﺪﻩ اﺳـﺖ از ﺗـﺎﺑﻊ‬ ‫)(‪ Print‬اﺳﺘﻔﺎدﻩ ﻣﻲ آﻨﻴﻢ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،file_number‬ﺷﻤﺎرﻩ ﻓﺎﻳﻠﻲ اﺳﺖ آﻪ ﻗﺒﻼ ﺑﺎ ﻳﻜﻲ از دو ﺣﺎﻟﺖ ﺑـﺎﻻ ﺑـﺎز ﺷـﺪﻩ اﺳـﺖ و‬ ‫ﺁرﮔﻮﻣﺎن ‪ output_list‬ﻧﻴﺰ ﻳﻚ ﺁراﻳﻪ ي ﭘـﺎراﻣﺘﺮي اﺳـﺖ، ﻳﻌﻨـﻲ ﻣﻘـﺎدﻳﺮ ﻳـﺎ ﻣﺘﻐﻴﺮهـﺎي ﻣﻘـﺪاردهﻲ‬ ‫ﺷﺪﻩ اي آﻪ ﺑﺎﻳﺪ در ﻓﺎﻳﻞ ﻧﻮﺷﺘﻪ ﺷﻮﻧﺪ.‬ ‫ﻧﻜﺘـﻪ: ﻣﻨﻈـﻮر از ﺁراﻳـﻪ ي ﭘـﺎراﻣﺘﺮي در ‪ ،VB‬ﺁرﮔﻮﻣـﺎﻧﻲ اﺳـﺖ آـﻪ ﻣـﻲ ﺗﻮاﻧـﺪ ﻣﻘـﺎدﻳﺮ ﻧﺎﻣﺤـﺪودي‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ﺑﭙﺬﻳﺮد. اﻳﻦ ﻣﻘﺎدﻳﺮ ﺑﺎ اﺳﺘﻔﺎدﻩ از آﺎراآﺘﺮ ),( از هﻢ ﺟﺪا ﻣﻲ ﺷﻮﻧﺪ.‬ ‫دﺳﺘﻮر زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)333.333,”‪Print(fNum, var1, var2, “My VB World‬‬ ‫اﻳﻦ دﺳﺘﻮر، ٤ ﻣﻘﺪار ﺷﺎﻣﻞ ﻣﻘﺪار ٢ ﻣﺘﻐﻴﺮ، ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي و ﻳـﻚ ﻣﻘـﺪار ﻋـﺪدي را در ﻓـﺎﻳﻠﻲ‬ ‫آﻪ ﺷﻤﺎرﻩ ﺁن در ﻋﺒﺎرت ‪ fNum‬وﺟﻮد دارد ذﺧﻴﺮﻩ ﻣﻲ آﻨﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ Print‬دادﻩ هﺎ را در ﺧﻄـﻮط ﻣﺠـﺰا ذﺧﻴـﺮﻩ ﻧﻤـﻲ آﻨـﺪ ﻳﻌﻨـﻲ اﻳﻨﻄـﻮر ﻧﻴـﺴﺖ آـﻪ ﺑـﺎ هـﺮ ﺑـﺎر‬ ‫ﻓﺮاﺧﻮاﻧﻲ اﻳﻦ ﺗﺎﺑﻊ، دادﻩ هﺎ در ﺧﻂ ﺑﻌﺪي ﻓﺎﻳﻞ ذﺧﻴﺮﻩ ﺷﻮﻧﺪ ﺑﻠﻜﻪ ﭘﺸﺖ ﺳﺮ هـﻢ و ﺑـﺪون ﻓﺎﺻـﻠﻪ‬ ‫ﻗﺮار ﺧﻮاهﻨﺪ ﮔﺮﻓﺖ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل، دﺳﺘﻮر زﻳﺮ ﻓﻘﻂ ﻳﻚ ﺧﻂ ﻣﺘﻨﻲ در ﻓﺎﻳﻠﻲ آﻪ ﺷﻤﺎرﻩ ﺁن در ‪ fNum‬وﺟـﻮد دارد ﻣـﻲ‬ ‫ﻧﻮﻳﺴﺪ:‬ ‫)" ‪Print(fNum, "This is the first half of the line‬‬ ‫)".‪Print(fNum, "and this is the second half of the same line‬‬ ‫ﺗﺎﺑﻊ )(‪ PrintLine‬هﻤﺎن آﺎري را اﻧﺠﺎم ﻣﻲ دهﺪ آﻪ ﺗﺎﺑﻊ )(‪ Print‬اﻧﺠﺎم ﻣﻲ دهﺪ ﺑـﺎ اﻳـﻦ ﺗﻔـﺎوت‬ ‫آﻪ ﺑﺎ هﺮ ﺑﺎر ﻓﺮاﺧﻮاﻧﻲ، دادﻩ را در ﺧﻄﻮط ﻣﺠﺰا ﻗﺮار ﻣﻲ دهـﺪ هﻤﺎﻧﻨـﺪ دﺳـﺘﻮر ‪ WriteLn‬در زﺑـﺎن‬ ‫ﭘﺎﺳﻜﺎل آﻪ اﻃﻼﻋﺎت را در ﺧﻄﻮط ﺟﺪا، ذﺧﻴﺮﻩ ﻣﻲ آﻨﺪ ﻳﺎ ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﺑﺮاي ﺧﻮاﻧﺪن دادﻩ هﺎﻳﻲ آﻪ ﺑﺎ ﺗﺎﺑﻊ )(‪ Print‬در ﻓﺎﻳـﻞ ذﺧﻴـﺮﻩ ﺷـﺪﻩ اﻧـﺪ از ﺗﻮاﺑـﻊ )(‪ LineInput‬و‬ ‫)(‪ Input‬اﺳﺘﻔﺎدﻩ ﻣﻲ آﻨﻴﻢ.‬ ‫ﺗﺎﺑﻊ )(‪ Print‬ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﺑﻴﻦ ﻓﻴﻠﺪهﺎي ﻣﺨﺘﻠﻒ در ﻳﻚ ﻓﺎﻳﻞ ﻓﺎﺻﻠﻪ اي ﻗﺮار ﻧﻤﻲ دهﺪ.‬ ‫ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ ﻓﻴﻠﺪهﺎﻳﻲ آﻪ در هﺮ ﺧﻂ ﻓﺎﻳﻞ ﻣﺘﻨﻲ ذﺧﻴﺮﻩ ﻣـﻲ ﺷـﻮﻧﺪ ﻣـﻲ ﺗﻮاﻧﻴـﺪ از آﻠﻤـﻪ‬ ‫آﻠﻴﺪي )‪ (Tab‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ ﺗﺎ ‪ VB‬در هﻨﮕﺎم ذﺧﻴـﺮﻩ دادﻩ هـﺎ در ﻓﺎﻳـﻞ، ﺑـﻴﻦ ﻓﻴﻠـﺪ هـﺎي ﻣﺨﺘﻠـﻒ‬ ‫ﻓﺎﺻﻠﻪ ﻗﺮار دهﺪ.‬ ‫هﻤﭽﻨﻴﻦ ﺧﻮد ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺮاي اﻳﻦ ﻓﺎﺻﻠﻪ ﻣﻘﺪاري ﺗﻌﻴﻴﻦ آﻨﻴﺪ. ﻣﺜﻼ: )21(‪Tab‬‬ ‫ﻣﺜﺎل زﻳﺮ ﻳﻚ ﻓﺎﻳﻞ ﻣﺘﻨﻲ را ﺳﺎﺧﺘﻪ و ﻣﻘﺪاري دادﻩ را در ﺁن ذﺧﻴﺮﻩ ﻣﻲ آﻨﺪ:‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٧٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫‪On Error Resume Next‬‬ ‫)” ‪Kill(“c:test.txt‬‬ ‫)(‪Dim fNum As Integer =FreeFile‬‬ ‫)‪FileOpen(fNum, “c:test.txt”, OpenMode.Output‬‬ ‫)33 ,)54(‪PrintLine(fNum, “Behrouz”, TAB(12), “Rad”, TAB(25), “Manager”, TAB‬‬ ‫)82 ,)54(‪PrintLine(fNum, “sina”, TAB(12), “ahmadi”, TAB(25), “Programmer”, TAB‬‬ ‫)14 ,)54(‪PrintLine(fNum, “arvin”, TAB(12), “sanaei”, TAB(25), “Engineer”, TAB‬‬ ‫)52 ,)54(‪PrintLine(fNum, “pedram”, TAB(12), “amiri”, TAB(25), “Administrator”, TAB‬‬ ‫)”*************************“ ,‪PrintLine(fNum‬‬ ‫)3 ,‪PrintLine(fNum, “Behrouz”, TAB, “Rad”, TAB, “Manager”, TAB‬‬ ‫)82 ,‪PrintLine(fNum, “sina”, TAB, “ahmadi”, TAB, “Programmer”, TAB‬‬ ‫)14 ,‪PrintLine(fNum, “arvin”, TAB, “sanaei”, TAB, “Engineer” , TAB‬‬ ‫)52 ,‪PrintLine(fNum, “pedram”, TAB, “amiri”, TAB, “Administrator”, TAB‬‬ ‫)‪FileClose(fNum‬‬ ‫ﺧﺮوﺟﻲ دﺳﺘﻮرات ﺑﺎﻻ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺧﻮاهﺪ ﺷﺪ:‬ ‫‪Behrouz‬‬ ‫‪Rad‬‬ ‫‪Manager‬‬ ‫33‬ ‫‪sina‬‬ ‫‪ahmadi‬‬ ‫‪Programmer‬‬ ‫82‬ ‫‪arvin‬‬ ‫‪sanaei‬‬ ‫‪Engineer‬‬ ‫14‬ ‫‪pedram‬‬ ‫‪amiri‬‬ ‫‪Administrator‬‬ ‫52‬ ‫*************************‬ ‫‪Behrouz‬‬ ‫‪Rad‬‬ ‫‪Manager‬‬ ‫33‬ ‫‪sina‬‬ ‫‪ahmadi‬‬ ‫‪Programmer‬‬ ‫82‬ ‫‪arvin‬‬ ‫‪sanaei‬‬ ‫‪Engineer‬‬ ‫14‬ ‫‪pedram‬‬ ‫‪amiri‬‬ ‫‪Administrator‬‬ ‫52‬ ‫)‪Input(file_number,var‬‬ ‫ﺑﺪﻳﻬﻲ اﺳﺖ آﻪ ﭘﺲ از ﻧﻮﺷﺘﻦ در ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒـﻲ، ﺑﺎﻳـﺪ ﺑﺘـﻮان اﻃﻼﻋـﺎت را از ﺁن ﺧﻮاﻧـﺪ و ﭘـﺮدازش‬ ‫آﺮد. ﺑﺮاي ﺧﻮاﻧﺪن اﻃﻼﻋﺎت از ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ، ﺑﺎﻳﺪ ﺁن را ﺑﻪ ﺻﻮرت ‪ Input‬ﺑﺎز آﺮد.‬ ‫ﺗﺎﺑﻊ )(‪ Input‬دادﻩ هﺎي ﻳﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ را ﺧﻮاﻧـﺪﻩ و ﺁﻧﻬـﺎ را در ﻣﺘﻐﻴـﺮي آـﻪ ﺑـﻪ ﻋﻨـﻮان دوﻣـﻴﻦ‬ ‫ﺁرﮔﻮﻣﺎن اﻳﻦ ﺗﺎﺑﻊ وﺟﻮد دارد ﻳﻌﻨﻲ ‪ var‬ﻣﻲ رﻳﺰد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ file_number‬ﺷﻤﺎرﻩ ﻓﺎﻳﻠﻲ اﺳـﺖ آـﻪ ﺑـﻪ ﺻـﻮرت ‪ Input‬ﺑـﺎز ﺷـﺪﻩ اﺳـﺖ و ﺁرﮔﻮﻣـﺎن‬ ‫‪ ،var‬ﻳـﻚ ﺁراﻳـﻪ ﭘـﺎراﻣﺘﺮي اﺳـﺖ آـﻪ ﺷـﺎﻣﻞ اﺳـﺎﻣﻲ ﻓﻴﻠـﺪهﺎ ﻳـﺎ ﻟﻴـﺴﺘﻲ از ﻣﺘﻐﻴﺮهـﺎ اﺳـﺖ آـﻪ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫اﻃﻼﻋﺎت ﺧﻮاﻧﺪﻩ ﺷﺪﻩ در ﺁﻧﻬﺎ ﻗﺮار ﻣﻲ ﮔﻴﺮد.‬ ‫در اﻳﻦ دﺳﺘﻮر، اﮔﺮ هﻨﮕﺎم ﺧﻮاﻧﺪن ﻓﺎﻳﻞ ﺗﻌﺪاد ﻓﻴﻠﺪهﺎﻳﻲ آﻪ ﺷﻤﺎ ﻧﺎم ﺁﻧﻬﺎ را در ﺁرﮔﻮﻣﺎن ‪ var‬ﻣـﻲ‬ ‫ﺁورﻳﺪ از ﺗﻌﺪاد ﻓﻴﻠﺪهﺎي ﻓﺎﻳﻞ آﻤﺘﺮ ﺑﺎﺷﺪ، ﻓﻴﻠـﺪهﺎي ﺑﻌـﺪي در ﻓﺮاﺧـﻮاﻧﻲ ﺑﻌـﺪي ﻓﺮﻣـﺎن )(‪Input‬‬ ‫ﻧﻤﺎﻳﺶ دادﻩ ﻣﻲ ﺷﻮﻧﺪ. وﻟﻲ ﭼﻨﺎﻧﭽﻪ ﺗﻌﺪاد ﻓﻴﻠﺪهﺎﻳﻲ آﻪ ﻧﺎم ﺁﻧﻬﺎ در ﺁرﮔﻮﻣﺎن ‪ var‬ﻣﻲ ﻧﻮﻳـﺴﻴﺪ،‬ ‫ﺑﻴﺸﺘﺮ از ﺗﻌﺪاد ﻓﻴﻠﺪهﺎي ﻳﻚ رآﻮرد ﻓﺎﻳﻞ ﺑﺎﺷﺪ، ﺑـﻪ ﺗﻌـﺪاد ﻻزم از رآﻮردهـﺎي ﺑﻌـﺪي ﺧﻮاﻧـﺪﻩ ﻣـﻲ‬ ‫ﺷﻮﻧﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل، دﺳﺘﻮرات زﻳﺮ ﻳﻚ ﻣﻘﺪار ﻋﺪدي و ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ را از ﻓـﺎﻳﻠﻲ آـﻪ ﺑـﺎز ﺷـﺪﻩ‬ ‫اﺳﺖ ﻣﻲ ﺧﻮاﻧﻨﺪ:‬ ‫‪Dim numVal As Long,DateVal As Date‬‬ ‫)‪Input(1,numVal‬‬ ‫)‪Input(1,DateVal‬‬ ‫)‪LineInput(file_number‬‬ ‫ﭘﻴﺸﻨﻬﺎد ﻣﻲ آﻨﻢ ﺑﺮاي ﺧﻮاﻧﺪن ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ از اﻳﻦ ﺗﺎﺑﻊ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ file_number‬ﺷﻤﺎرﻩ ﻓﺎﻳـﻞ ﺑـﺎز ﺷـﺪﻩ اﺳـﺖ و اﻳـﻦ ﺗـﺎﺑﻊ ﻳـﻚ ﺳـﻄﺮ از ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ را‬ ‫ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ، در اوﻟﻴﻦ ﺑﺎر ﻓﺮاﺧﻮاﻧﻲ، اوﻟـﻴﻦ ﺧـﻂ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ را ﺑﺮﮔـﺸﺖ ﻣـﻲ دهـﺪ و در ﻓﺮاﺧـﻮاﻧﻲ‬ ‫ﺑﻌﺪي دوﻣﻴﻦ ﺧﻂ و ﺑﻪ هﻤﻴﻦ ﻣﻨﻮال.‬ ‫دﺳﺘﻮرات زﻳﺮ ﺳﻄﺮهﺎي اول و دوم ﻳﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ را در ﻣﺘﻐﻴﺮهـﺎي 1‪ Line‬و 2‪ Line‬ﻗـﺮار ﻣـﻲ‬ ‫دهﻨﺪ.‬ ‫)‪Line1 =LineInput(fNum‬‬ ‫)‪Line2 =LineInput(fNum‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٨٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﺑﺮاي ذﺧﻴﺮﻩ ﺳﺎزي ﻣﺘﻦ هﺎي ﺳﺎدﻩ در ﻳﻚ ﻓﺎﻳﻞ، ﻳﻚ ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ درﺳﺖ آﻨﻴـﺪ و دادﻩ هـﺎي ﺧـﻮد‬ ‫را در ﺁن ذﺧﻴﺮﻩ آﺮدﻩ و در ﻣﻮﻗﻊ ﻟﺰوم ﺑﺮاي ﺧﻮاﻧﺪن ﺧﻂ ﺑﻪ ﺧﻂ دادﻩ هﺎي ذﺧﻴﺮﻩ ﺷﺪﻩ ﺑـﺎ اﺳـﺘﻔﺎدﻩ‬ ‫از ﺗﺎﺑﻊ )(‪ LineInput‬ﻳﺎ ﺑﺮاي ﺧﻮاﻧﺪن آﻞ ﻓﺎﻳﻞ از ﺗﺎﺑﻊ )(‪ FileGet‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫, )] ‪FilePut(file_number,value [,record_number‬‬ ‫)] ‪FileGet(file_number,value [,record_number‬‬ ‫اﻳﻦ دو ﺗﺎﺑﻊ ﺑﺮاي ﺧﻮاﻧﺪن ﻳﺎ ﻧﻮﺷﺘﻦ رآﻮردهﺎ ﺑﻪ ﻳﺎ از ﻓﺎﻳﻞ ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ FilePut‬ﺑﺮاي ﻧﻮﺷﺘﻦ رآﻮرد و ﺗﺎﺑﻊ )(‪ FileGet‬ﺑﺮاي ﺧﻮاﻧﺪن رآﻮرد اﺳﺘﻔﺎدﻩ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫ﺑﺮاي آﺎر ﺑﺎ اﻳﻦ ﺗﻮاﺑﻊ ﻧﻴﺎز ﺑﻪ داﻧﺴﺘﻦ ﺷﻤﺎرﻩ رآﻮردي دارﻳﺪ آـﻪ ﻣـﻲ ﺧﻮاهﻴـﺪ ﺁن را ﺑﺨﻮاﻧﻴـﺪ ﻳـﺎ در‬ ‫ﻓﺎﻳﻞ ﺑﻨﻮﻳﺴﻴﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،file_number‬ﺷﻤﺎرﻩ ﻓﺎﻳﻞ اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،record_number‬ﺷﻤﺎرﻩ رآﻮردي اﺳﺖ آﻪ ﺑﺎﻳﺪ ﺧﻮاﻧﺪﻩ ﻳﺎ ﻧﻮﺷﺘﻪ ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ record_number‬ﻳﻚ ﭘﺎراﻣﺘﺮ اﺧﺘﻴﺎري اﺳﺖ و ﭼﻨﺎﻧﭽﻪ از ذآﺮ ﺁن ﺧﻮدداري ﺷﻮد، رآـﻮرد‬ ‫در ﻣﻜﺎن ﻓﻌﻠﻲ اﺷﺎرﻩ ﮔﺮ ﻓﺎﻳﻞ ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮد. )در ﺗﺎﺑﻊ )(‪(FilePut‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،value‬ﻣﺘﻐﻴﺮ رآﻮردي اﺳﺖ آﻪ در ﻓﺎﻳﻞ ﻧﻮﺷﺘﻪ ﺷﺪﻩ اﺳﺖ ﻳﺎ ﻣﻲ ﺷﻮد.‬ ‫ﭘﺲ از اﻳﻨﻜﻪ ﻳﻚ رآﻮرد ﺑﻪ ﻓﺎﻳﻞ ﻧﻮﺷﺘﻪ ﻳﺎ از ﻓﺎﻳﻞ ﺧﻮاﻧـﺪﻩ ﺷـﺪ، رآـﻮرد ﺑﻌـﺪ از ﺁن ﺑـﻪ ﻋﻨـﻮان رآـﻮرد‬ ‫ﺟﺎري در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔﺮ ﺗﺎﺑﻊ )(‪ ١٠ ،FilePut‬ﺑﺎر ﭘـﺸﺖ ﺳـﺮ هـﻢ و ﺑـﺪون ﺗﻌﻴـﻴﻦ آـﺮدن ﺷـﻤﺎرﻩ رآـﻮرد‬ ‫ﻓﺮاﺧﻮاﻧﻲ ﺷﻮد، ٠١ رآﻮرد اول ﻓﺎﻳﻞ ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ، اﻳﺠﺎد ﻳﺎ ﺑﺎزﻧﻮﻳﺴﻲ ﻣﻲ ﺷﻮد.‬ ‫از ﺁﻧﺠﺎﻳﻲ آﻪ ﻓﺎﻳﻞ ﺑﺎ ﺳﺎﺧﺘﺎر دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ، اﻧﻌﻄﺎف ﭘﺬﻳﺮﺗﺮﻳﻦ ﺳﺎﺧﺘﺎر و ﺑﻴﺸﺘﺮﻳﻦ آﺎرﺑﺮد را‬ ‫دارد، ﺑﺎ ذآﺮ ﭼﻨﺪ ﻣﺜﺎل ﺑﺎ ﻧﺤﻮﻩ ﻋﻤﻠﻜﺮد اﻳﻦ ﺳﺎﺧﺘﺎر ﺑﻴﺸﺘﺮ ﺁﺷﻨﺎ ﻣﻲ ﺷﻮﻳﻢ:‬ ‫در اﻳﻨﺠﺎ ﻣﻦ ﻗﺼﺪ اﻳﺠﺎد ﻳﻚ ﻓﺎﻳﻞ ﻧﻮع دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ را ﺟﻬـﺖ ﻧﮕﻬـﺪاري ﻣﺸﺨـﺼﺎت ﻣﺤـﺼﻮل‬ ‫ﻳﻚ ﺷﺮآﺖ دارم. هﺮ ﻣﺸﺨﺼﻪ از اﻳﻦ ﻣﺤﺼﻮل در ﻳﻚ ﻣﺘﻐﻴﺰ ﺑﻪ ﻧﺎم ‪ ProductRecord‬ﻗﺮار ﺧﻮاهـﺪ‬ ‫ﮔﺮﻓﺖ. ﺳﺎﺧﺘﺎر ‪ ProductRecord‬را ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺗﻌﺮﻳﻒ ﻣﻲ آﻨﻢ:‬ ‫ﺗﻮﺟﻪ: در ‪ VB.NET‬از آﻠﻤﻪ آﻠﻴﺪي ‪ Structure‬ﺟﻬﺖ ﺗﻌﺮﻳـﻒ ﻳـﻚ ﺳـﺎﺧﺘﺎر ﺳﻔﺎرﺷـﻲ اﺳـﺘﻔﺎدﻩ‬ ‫ﻣﻲ آﻨﻴﻢ. اﻳﻦ آﻠﻤﻪ ﺟﺎﻳﮕﺰﻳﻦ آﻠﻤﻪ آﻠﻴﺪي ‪ Type‬در 0.6.‪ VB‬ﺷﺪﻩ اﺳﺖ.‬ ‫‪Structure ProductRecord‬‬ ‫‪ProductID As String‬‬ ‫‪Description As String‬‬ ‫‪Price As Decimal‬‬ ‫‪End Type‬‬ ‫اﻃﻼﻋﺎت آﺎﻻ ﻗﺒﻞ از ذﺧﻴﺮﻩ ﺷﺪن در ﻓﺎﻳﻞ، در هﺮ ﻳﻚ از اﻳﻦ ٣ ﻣﺘﻐﻴﺮ ﻗﺮار ﺧﻮاهﻨﺪ ﮔﺮﻓﺖ.‬ ‫ﺣــﺎﻻ ﺑــﺮاي دﺳﺘﺮﺳــﻲ ﺑــﻪ ﻓﻴﻠــﺪهﺎي اﻳــﻦ ﺳــﺎﺧﺘﺎر ﺑﺎﻳــﺪ ﻣﺘﻐﻴــﺮي از ﻧــﻮع اﻳــﻦ ﺳــﺎﺧﺘﺎر ﻳﻌﻨــﻲ‬ ‫‪ ProductRecord‬ﺗﻌﺮﻳﻒ آﻨﻴﻢ:‬ ‫‪Dim PRec As ProductRecord‬‬ ‫ﺣﺎل ﻣﻲ ﺗﻮاﻧﻴﻢ ﻣﻘﺎدﻳﺮ ﺧﻮد را ﺑﻪ ﻓﻴﻠﺪهﺎي ﻣﺘﻐﻴﺮ ‪ Prec‬ﻧﺴﺒﺖ دهﻴﻢ:‬ ‫” ‪PRec.ProductID = “TV00180-A‬‬ ‫” ‪PRec.Description = “SONY TV‬‬ ‫99.997 = ‪PRec.Price‬‬ ‫اآﻨﻮن هﻤﻪ ﭼﻴﺰ ﺑﺮاي ذﺧﻴﺮﻩ آﺮدن ﻣﻘﺎدﻳﺮ وارد ﺷﺪﻩ در ﻓﺎﻳﻞ ﻣﺎ ﺁﻣﺎدﻩ اﺳﺖ اﻣﺎ ﻗﺒﻞ از اﻧﺠـﺎم اﻳـﻦ‬ ‫آﺎر ﺑﺎﻳﺪ ﻓﺎﻳﻞ را اﻳﺠﺎد آﻨﻴﻢ:‬ ‫)(‪fNum =FreeFile‬‬ ‫)‪FileOpen(fNum, “C:products.dat ”,OpenMode.Random‬‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﻣﻦ در ﺗﺎﺑﻊ )(‪ FileOpen‬از ذآﺮ ﻣﺘﻐﻴﺮ ﺁﺧﺮ آﻪ ﻃـﻮل رآـﻮرد را ﺗﻌﻴـﻴﻦ ﻣـﻲ‬ ‫آﻨﺪ ﺧﻮدداري آﺮدم. از ﺁﻧﺠﺎﺋﻴﻜﻪ ﻓﻴﻠﺪهﺎي ﻣﺎ داراي ﻣﻘﺎدﻳﺮ رﺷﺘﻪ اي هﺴﺘﻨﺪ و ﻃـﻮل ﺁﻧﻬـﺎ از ﻗﺒـﻞ‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٩٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﻣﺸﺨﺺ ﻧﻴﺴﺖ )ﻣﺘﻐﻴﺮ اﺳﺖ(، اﺟﺎزﻩ ﻣﻲ دهﻴﻢ آﻪ ﺗﺎﺑﻊ ﺑﻪ ﻃﻮر ﺧﻮدآﺎر رآﻮردهـﺎ را ادارﻩ و ﻃـﻮل‬ ‫ﺁﻧﻬﺎ را ﻣﺪﻳﺮﻳﺖ آﻨﺪ. اﺻﻮل آﺎر ﺑﻪ اﻳﻦ ﺷﻜﻞ اﺳﺖ آﻪ هﻨﮕﺎم ذﺧﻴﺮﻩ ﻣﺘﻐﻴﺮ رﺷﺘﻪ اي، ﻃﻮل ﺁن ﻧﻴـﺰ‬ ‫هﻤﺮاﻩ ﺑﺎ ﻣﻘﺪار ﺁن در ﻓﺎﻳﻞ ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮد ﭘﺲ ﺷﻤﺎ ﻧﻴﺎزي ﺑﻪ داﻧﺴﺘﻦ ﻃﻮل هﺮ رآﻮرد ﻧﺪارﻳﺪ.‬ ‫و ﺣﺎﻻ ﻣﻘﺎدﻳﺮ ﻧﺴﺒﺖ دادﻩ ﺷﺪﻩ را ﺑﺎ دﺳﺘﻮر زﻳﺮ در ﻓﺎﻳﻞ ذﺧﻴﺮﻩ ﻣﻲ آﻨﻴﻢ:‬ ‫)‪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‬‬ ‫99.997 = ‪PRec.Price‬‬ ‫)(‪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‬‬ ‫99.996 = ‪PRec.Price‬‬ ‫)‪FilePut(fNum,PRec‬‬ ‫)(‪PRec =New ProductRecord‬‬ ‫”‪PRec.ProductID = “TV-FST‬‬ ‫” ‪PRec.Description = “And this is the real FST TV‬‬ ‫99.993 = ‪Prec.Price‬‬ ‫)‪FilePut(fNum,Prec‬‬ ‫)‪FileClose(fNum‬‬ ‫)(‪fNum = FreeFile‬‬ ‫)‪FileOpen(fNum, “C:products.dat ”, OpenMode.Random‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٠٥‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)(‪Prec =New ProductRecord‬‬ ‫)2,‪FileGet(fNum,Prec‬‬ ‫)‪FileClose(fNum‬‬ ‫)‪Console.WriteLine(Prec.ProductID‬‬ ‫)‪Console.WriteLine(Prec.Description‬‬ ‫)‪Console.WriteLine(Prec.Price‬‬ ‫هﻤﺎن ﻃﻮر آﻪ ﻣﺸﺎهﺪﻩ ﻣﻲ آﻨﻴﺪ، ﻓﻴﻠـﺪهﺎي ‪ ProductID‬و ‪ Description‬ﻣﺤـﺼﻮﻻت ﻣﺨﺘﻠـﻒ،‬ ‫آﻪ از ﻧﻮع رﺷﺘﻪ اي هﺴﺘﻨﺪ داراي ﻃﻮل هﺎي ﻣﺨﺘﻠﻒ هﺴﺘﻨﺪ.‬ ‫ﺳﻪ ﻗﺴﻤﺖ اول آﺪ ﺑﺎﻻ، ٣ رآﻮرد ﻣﺨﺘﻠﻒ را در ﻓﺎﻳﻞ ﺗﺼﺎدﻓﻲ ذﺧﻴﺮﻩ آﺮدﻩ و ﺳـﭙﺲ ﻓﺎﻳـﻞ را ﻣـﻲ‬ ‫ﺑﻨﺪد.‬ ‫ﻗﺴﻤﺖ ﺁﺧﺮ آﺪ ﻧﻴﺰ، دوﻣﻴﻦ رآﻮرد ﻓﺎﻳﻞ را ﺧﻮاﻧﺪﻩ و ﻣﻘﺎدﻳﺮ ﺁن را در ﺧﺮوﺟﻲ ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﻧﻜﺘﻪ: در 0.6.‪ ،VB‬هﺮ رآﻮرد در ﻓﺎﻳﻞ ﺗﺼﺎدﻓﻲ ﺑﺎﻳﺪ داراي ﻃـﻮل ﺛﺎﺑـﺖ ﻣـﻲ ﺑـﻮد اﻣـﺎ در ‪،VB.NET‬‬ ‫ﻣﻲ ﺗﻮاﻧﻴﺪ رآﻮردهﺎﻳﻲ اﻳﺠﺎد و در ﻓﺎﻳﻞ ﺗﺼﺎدﻓﻲ ﻗﺮار دهﻴﺪ آﻪ داراي ﻃﻮل ﻣﺘﻐﻴﺮ ﺑﺎﺷﻨﺪ.‬ ‫)‪Write(file_number,output_list) , WriteLine(file_number,output_list‬‬ ‫ﺗﺎﺑﻊ )(‪ Write‬ﺟﻬﺖ ذﺧﻴﺮﻩ دادﻩ هﺎ در ﻳﻚ ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ ﺑﻪ آﺎر ﻣﻲ رود.‬ ‫ﺁرﮔﻮﻣﺎن ‪ file_number‬ﺷﻤﺎرﻩ ﻓﺎﻳﻠﻲ اﺳﺖ آﻪ دادﻩ هﺎ در ﺁن ذﺧﻴﺮﻩ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ output_list‬ﻧﻴﺰ آﻪ ﻳﻚ ﺁراﻳﻪ ي ﭘﺎراﻣﺘﺮي اﺳﺖ، ﻟﻴﺴﺘﻲ از دادﻩ هﺎﻳﻲ اﺳـﺖ آـﻪ ﻣـﻲ‬ ‫ﺧﻮاهﻴﻢ در ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ ﻧﻮﺷﺘﻪ ﺷﻮﻧﺪ و ﻣﻲ ﺗﻮاﻧﻨﺪ ﻣﺘﻐﻴﺮهـﺎي ﻣﻘـﺪاردهﻲ ﺷـﺪﻩ ﻳـﺎ ﺧـﻮد ﻣﻘـﺪار‬ ‫ﻣﻮرد ﻧﻈﺮ ﺑﺎﺷﻨﺪ. دادﻩ هﺎ در ﺁرﮔﻮﻣﺎن ‪ ،output_list‬ﺑﺎ آﺎراآﺘﺮ ),( از ﻳﻜﺪﻳﮕﺮ ﺟﺪا ﻣﻲ ﺷﻮﻧﺪ.‬ ‫دادﻩ هﺎﻳﻲ آﻪ ﺑﺎ ﺗﺎﺑﻊ )(‪ Write‬در ﻓﺎﻳﻞ ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮﻧﺪ ﻣﻌﻤﻮﻻ ﺑﺎ ﺗـﺎﺑﻊ )(‪ Input‬ﺧﻮاﻧـﺪﻩ ﻣـﻲ‬ ‫ﺷﻮﻧﺪ.‬ ‫دﺳﺘﻮرات زﻳﺮ، ﻳﻚ ﻣﻘﺪار ﻋﺪدي و ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ را در ﻳﻚ ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ ﻣﻲ ﻧﻮﻳﺴﻨﺪ:‬ ‫400.0033 = ‪NumVal‬‬ ‫#9991/90/40# = ‪DateVal‬‬ ‫)‪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‬‬ ‫ﺧﺮوﺟﻲ دﺳﺘﻮرات ﻓﻮق ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺧﻮاهﺪ ﺷﺪ:‬ ‫”‪“Behrouz Rad”, 33, ”Manager‬‬ ‫”‪“Sina Ahmadi”, 24, ”Programmer‬‬ ‫”‪“Arvin Sanaei”, 37, ”Engineer‬‬ ‫”‪“Pedram Amiri”, 28, ”Administrator‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫١٥‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)‪Seek(file_number [,position ]) , Loc(file_number‬‬ ‫ﺗﺎﺑﻊ )(‪ ،Loc‬ﻣﻜﺎن ﺟﺎري اﺷﺎرﻩ ﮔﺮ ﻓﺎﻳﻞ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ Seek‬ﻧﻴﺰ در ﺻﻮرﺗﻲ آﻪ ﺑﺪون ذآﺮ ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ position‬ﺑﻪ آﺎر رود، ﻋﻤﻠﻲ ﻣـﺸﺎﺑﻪ‬ ‫ﺗﺎﺑﻊ )(‪ Loc‬را اﻧﺠﺎم ﻣﻲ دهﺪ.‬ ‫در ﻓﺎﻳﻞ هﺎي ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ، ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ دو ﺗﺎﺑﻊ، ﺷﻤﺎرﻩ ﺁﺧـﺮﻳﻦ رآـﻮردي اﺳـﺖ‬ ‫آﻪ از ﻓﺎﻳﻞ ﺧﻮاﻧﺪﻩ ﺷﺪﻩ ﻳﺎ در ﻓﺎﻳﻞ ﻧﻮﺷﺘﻪ ﺷﺪﻩ.‬ ‫در ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ، اﻳﻦ ﻣﻘﺪار، ﺑﺎ ﺗﻘﺴﻴﻢ ﺑﺎﻳﺖ ﺧﻮاﻧﺪﻩ ﺷﺪﻩ ﺟﺎري ﺑﺮ ﻋﺪد ٨٢١ ﺑﻪ دﺳـﺖ ﻣـﻲ‬ ‫ﺁﻳﺪ.‬ ‫در ﻓﺎﻳﻞ هﺎي ﺑﺎﻳﻨﺮي ﻧﻴﺰ، ﺷﻤﺎرﻩ ﺁﺧﺮﻳﻦ ﺑﺎﻳﺖ ﺧﻮاﻧﺪﻩ ﺷﺪﻩ از ﻳﺎ ﻧﻮﺷﺘﻪ ﺷـﺪﻩ ﺑـﻪ ﻓﺎﻳـﻞ ﺑـﻪ ﻋﻨـﻮان‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ ﺧﻮاهﺪ ﺑﻮد.‬ ‫ﺷﻤﺎ ﻗﺎدر ﺑﻪ ﺗﻌﻴﻴﻦ ﻣﻜﺎن ﺷﺮوع ﺧﻮاﻧﺪن ﻳﺎ ﻣﻜﺎن ﻧﻮﺷﺘﻪ ﺷﺪن رآـﻮرد در ﻓﺎﻳـﻞ ﺑـﺎ ﻣﻘـﺪاردهﻲ ﺑـﻪ‬ ‫ﺁرﮔﻮﻣﺎن ‪ position‬از ﺗﺎﺑﻊ )(‪ Seek‬هﺴﺘﻴﺪ.‬ ‫ﻣﺜﻼ ﺑﺮاي ﺁﻧﻜﻪ اﺷﺎرﻩ ﮔﺮ رآﻮرد را در ﻳﻚ ﻓﺎﻳﻞ ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ ﺑﻪ ﺳﻮﻣﻴﻦ رآﻮرد ﺑﺒﺮﻳﺪ ﻳﺎ ﺑـﻪ‬ ‫ﻋﺒﺎرت دﻳﮕﺮ ﺁن را ﺑﻪ ﻋﻨﻮان رآﻮرد ﻓﻌﺎل ﻣﻨﻈﻮر آﻨﻴﺪ، ﻣﻲ ﺗﻮاﻧﻴﺪ از دﺳﺘﻮر زﻳﺮ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ:‬ ‫)3,‪Seek(fNum‬‬ ‫, )] ‪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‬‬
‫)‪Width(fNum,length‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻧﻴﺰ ﻳﻚ ﺑﺴﻴﺎر ﺑـﺴﻴﺎر آﺎرﺁﻣـﺪ اﺳـﺖ آـﻪ ﺟﻬـﺖ ﺗﻌﻴـﻴﻦ ﺑﻴـﺸﺘﺮﻳﻦ ﻃـﻮل ﺧـﻂ ﻳﻌﻨـﻲ ﺗﻌـﺪاد‬ ‫آﺎراآﺘﺮهﺎي ﻗﺎﺑﻞ ذﺧﻴﺮﻩ ﺳﺎزي در هﺮ ﺧﻂ آﻪ ﻣﻲ ﺗﻮاﻧﺪ در ﻳﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ ﻧﻮﺷـﺘﻪ ﺷـﻮد، ﺑـﻪ‬ ‫آﺎر ﻣﻲ رود.‬ ‫ﺑﻴﺸﺘﺮﻳﻦ ﻃﻮل ﺧﻂ ﺑﻪ وﺳﻴﻠﻪ ي ﺁرﮔﻮﻣﺎن ‪ length‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد.‬ ‫در ﺻــﻮرﺗﻲ آــﻪ آﺎراآﺘﺮهــﺎي ﺷــﻤﺎ از ﺗﻌــﺪاد ﺗﻌﻴــﻴﻦ ﺷــﺪﻩ در ﺁرﮔﻮﻣــﺎن ‪ length‬ﺑﻴــﺸﺘﺮ ﺑﺎﺷــﺪ،‬ ‫آﺎراآﺘﺮهﺎي اﺿﺎﻓﻲ ﺑﻪ ﻃﻮر اﺗﻮﻣﺎﺗﻴﻚ ﺑﻪ ﺧﻂ ﺑﻌﺪ ﻣﻨﺘﻘﻞ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫اﺑﻦ ﺗﺎﺑﻊ را ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺎ ﺗﻮاﺑﻊ )(‪ Print‬و )(‪) Write‬آﻪ دادﻩ هـﺎ را در ﻳـﻚ ﺧـﻂ و ﭘـﺸﺖ ﺳـﺮ هـﻢ‬ ‫ذﺧﻴﺮﻩ ﻣﻲ آﻨﻨﺪ( ﺟﻬﺖ ﺗﻌﻴﻴﻦ ﺗﻌﺪاد آﺎراآﺘﺮهﺎي ذﺧﻴﺮﻩ ﺷﻮﻧﺪﻩ در هﺮ ﺧﻂ، ﺑﻪ آﺎر ﺑﺮﻳﺪ.‬ ‫هﻤﭽﻨﻴﻦ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺗﺎﺑﻊ )(‪ Width‬را ﺑﺎ ﺗﻮاﺑﻊ )(‪ PrintLine‬و )(‪ WriteLine‬ﻧﻴـﺰ )آـﻪ دادﻩ هـﺎ را‬ ‫در ﺧﻄﻮط ﺟﺪا ذﺧﻴﺮﻩ ﻣﻲ آﻨﻨﺪ( ﺑﻪ آﺎر ﺑﺒﺮﻳﺪ.‬ ‫)‪FileAttr(file_number‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻋﺪد از ﻧﻮع ‪ Integer‬را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ آﻪ ﻣـﺸﺨﺺ آﻨﻨـﺪﻩ ي ﺣﺎﻟـﺖ ﺑـﺎز ﺷـﺪن‬ ‫ﻳﻚ ﻓﺎﻳﻞ ﺑﺎز اﺳﺖ.‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ، در ﺟﺪول زﻳﺮ ﻣﺸﺎهﺪﻩ ﻣﻲ آﻨﻴﺪ:‬ ‫ﻣﻘﺎدﻳﺮي آﻪ ﺗﺎﺑﻊ )(‪ FileAttr‬ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‬ ‫ﻣﺪ ﺑﺎز ﺷﺪن‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ‬ ‫‪Input‬‬ ‫1‬ ‫‪Output‬‬ ‫2‬ ‫‪Random‬‬ ‫4‬ ‫‪Append‬‬ ‫8‬ ‫‪Binary‬‬ ‫23‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٣٥‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)‪:(Random Numbers‬‬ ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺮاي اﻳﺠﺎد اﻋﺪاد ﺗﺼﺎدﻓﻲ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‬ ‫‪ VB.NET‬دو ﺗﺎﺑﻌﻲ آﻪ در 0.6.‪ VB‬ﺑﺮاي درﺳﺖ آﺮدن اﻋﺪاد ﺗﺼﺎدﻓﻲ ﺑﻪ آـﺎر ﻣـﻲ روﻧـﺪ )‪ Rnd‬و‬ ‫‪ (Randomize‬را ﭘﺸﺘﻴﺒﺎﻧﻲ ﻣﻲ آﻨﺪ اﻣﺎ از ﺁﻧﺠﺎ آﻪ در ‪ ،VB.NET‬اآﺜـﺮ ﺗﻮاﺑـﻊ، دﺳـﺘﻪ ﺑﻨـﺪي و در‬ ‫آﻼس ﺧﺎص ﺧﻮدﺷﺎن ﻗﺮار دادﻩ ﺷﺪﻩ اﻧﺪ، اﻳـﻦ دو ﺗـﺎﺑﻊ ﻧﻴـﺰ در آـﻼس ‪ System.Random‬ﻗـﺮار‬ ‫دادﻩ ﺷﺪﻩ اﻧﺪ.‬ ‫)] ‪Rnd([seed‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، در ﺻﻮرﺗﻲ آﻪ ﺑﺪون ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ﺧﻮد ﺑﻪ آﺎر رود، ﻳﻚ ﻋﺪد ﺗﺼﺎدﻓﻲ ﺑـﻴﻦ ﺻـﻔﺮ و ﻳـﻚ‬ ‫را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،seed‬ﻳﻚ ﻋﺒﺎرت ﻋﺪدي اﺳﺖ آﻪ ﻋﺪد ﺗﺼﺎدﻓﻲ ﺑﺎﻳﺪ ﺑﺮ ﺣﺴﺐ ﺁن ﺗﻮﻟﻴﺪ ﺷﻮد.‬ ‫ﻣﺜﻼ دﺳﺘﻮر 01*)(‪ ،Rnd‬ﻳﻚ ﻋﺪد ﺗﺼﺎدﻓﻲ ﺑﻴﻦ ﺻﻔﺮ و دﻩ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻧﻜﺘﻪ: هﻤﻴﺸﻪ ﺑﻴﻦ ﺗﺎﺑﻊ )(‪ Rnd‬و ﻋﺪدي آﻪ ﻣﻲ ﺧﻮاهﻴﺪ ﻋﺪد ﺗﺼﺎدﻓﻲ ﺑﺮ ﻣﺒﻨﺎي ﺁن ﺗﻮﻟﻴﺪ ﺷـﻮد،‬ ‫از آﺎراآﺘﺮ )*( اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﺗﻮﺟﻪ: ﺗﺮﺗﻴﺐ ﺗﻮﻟﻴﺪ اﻋﺪاد ﺗﺼﺎدﻓﻲ در اﻳـﻦ ﺗـﺎﺑﻊ هﻤﻴـﺸﻪ ﺑـﻪ ﻳـﻚ ﻣﻨـﻮال اﺳـﺖ. ﻣـﺜﻼ اﮔـﺮ دﺳـﺘﻮر‬ ‫01*)(‪ Rnd‬را ٣ ﺑﺎر ﭘﺸﺖ ﺳﺮ هﻢ اﺟـﺮا آﻨـﻴﻢ، هﻤﻴـﺸﻪ ﺳـﻪ ﻋـﺪد )574550.7، 42433.5،‬ ‫681597.5( ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﺪ ﺷﺪ.‬ ‫ﺑﺮاي ﺟﻠﻮﮔﻴﺮي از اﻳﻦ آـﺎر و ﺗﻐﻴﻴـﺮ ﺗﺮﺗﻴـﺐ ﺗﻮﻟﻴـﺪ اﻋـﺪاد ﺗـﺼﺎدﻓﻲ، از ﺗـﺎﺑﻊ )(‪ Randomize‬آـﻪ در‬ ‫ﻗﺴﻤﺖ ﺑﻌﺪي ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻩ اﺳﺖ، اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﻣﺜﻼ:‬ ‫‪Dim I as Integer‬‬ ‫)(‪Randomize‬‬ ‫01 * )(‪I = Rnd‬‬ ‫اﮔﺮ ﻣﻘﺪاري در ﺁرﮔﻮﻣﺎن ‪ seed‬ذآﺮ ﺷﻮد، ﻋﺪد ﺗـﺼﺎدﻓﻲ آـﻪ اﻳﺠـﺎد ﺧﻮاهـﺪ ﺷـﺪ، ﺑـﻴﻦ ﺻـﻔﺮ ﺗـﺎ ﺁن‬ ‫ﻋﺪدي اﺳﺖ آﻪ در ﺁرﮔﻮﻣﺎن ‪ seed‬ذآﺮ ﺷﺪﻩ. ﮔﺎهﻲ اوﻗﺎت ﻧﻴﺎز دارﻳﺪ ﺗﺎ ﺑـﻴﻦ ﻣﺤـﺪودﻩ اي دﻟﺨـﻮاﻩ‬ ‫ﻣﺜﻼ: 5 ﺗﺎ 01، ﻋﺪدي ﺗﺼﺎدﻓﻲ اﻳﺠﺎد آﻨﻴﺪ. ﺑﺪﻳﻦ ﻣﻨﻈﻮر ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ آﻨﻴﺪ:‬ ‫)‪randomNumber =Int((upper – lower + 1) * Rnd() + lower‬‬ ‫در اﻳﻦ دﺳﺘﻮر، ﻣﺘﻐﻴﺮ ‪ ،upper‬ﺣﺪ ﺑـﺎﻻي ﻣﺤـﺪودﻩ ي ﻣـﺎ )ﻣـﺜﻼ 01( و ﻣﺘﻐﻴـﺮ ‪ ،lower‬ﺣـﺪ ﭘـﺎﻳﻴﻦ‬ ‫ﻣﺤﺪودﻩ )ﻣﺜﻼ 5( اﺳﺖ.‬ ‫ﻧﻜﺘﻪ: در آﺪ ﺑﺎﻻ، ﺟﻤﻊ آﺮدن ﻧﺘﻴﺠﻪ ﻗﺴﻤﺖ اول ﺑﺎ ﻋﺪد 1، از ﺗﻮﻟﻴﺪ ﻋﺪد ﺗﺼﺎدﻓﻲ ﺑﻴﻦ ﺻﻔﺮ و ﻳـﻚ‬ ‫ﺟﻠﻮﮔﻴﺮي ﻣﻲ آﻨﺪ. ﭘﻴﺸﻨﻬﺎد ﻣﻲ آﻨﻢ هﻤﻴﺸﻪ در ﺗﻮﻟﻴﺪ اﻋﺪاد ﺗـﺼﺎدﻓﻲ، ﻣﻘـﺪار ‪ seed‬را ﺑـﺎ ﻋـﺪد‬ ‫ﻳﻚ ﺟﻤﻊ آﻨﻴﺪ.‬ ‫ﺗﻮﺟﻪ: ﺗﺎﺑﻊ ‪ Next‬ﻧﻴﺰ آﻪ در آﻼس ‪ System.Random‬ﻗﺮار دارد ﻗﺎدر ﺑﻪ اﻳﺠﺎد ﻳﻚ ﻋﺪد ﺗـﺼﺎدﻓﻲ‬ ‫در ﻣﺤﺪودﻩ اي ﺧﺎص اﺳﺖ.‬ ‫] ‪Randomize [seed‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، هﺴﺘﻪ ي ﺗﻮﻟﻴﺪ اﻋﺪاد ﺗﺼﺎدﻓﻲ را ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ هﻤﻴﺸﻪ ﺑﺎ ﺗﺎﺑﻊ )(‪ Rnd‬ﺑﻪ آﺎر ﻣﻲ رود و ﻣﻌﻤﻮﻻ ﻗﺒﻞ از ﺁن ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،seed‬ﻳﻚ ﻣﻘﺪار ﻋﺪدي اﺳﺖ آﻪ ﺑﺮاي ﺗﻮﻟﻴﺪ هﺴﺘﻪ ي اﻋﺪاد ﺗـﺼﺎدﻓﻲ ﺑـﻪ آـﺎر‬ ‫ﻣﻲ رود. ﺑﻬﺘﺮ اﺳﺖ از ذآﺮ اﻳﻦ ﻣﻘﺪار ﺧﻮدداري آﻨﻴﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٤٥‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)‪:(Graphics‬‬ ‫ﺗﻮاﺑﻊ ﮔﺮاﻓﻴﻜﻲ‬ ‫در اﻳﻦ ﻗﺴﻤﺖ، دو ﺗﺎﺑﻊ در ‪ VB.NET‬آﻪ ﺑﺮاي ﺗﻌﺮﻳﻒ رﻧـﮓ ار ﺁﻧﻬـﺎ اﺳـﺘﻔﺎدﻩ ﻣـﻲ ﺷـﻮد را ﺗﻮﺿـﻴﺢ‬ ‫ﻣﻲ دهﻢ.‬ ‫ﺗﻮﺟﻪ: ﺗﻮاﺑـﻊ )(‪ LoadPicture‬و )(‪ SavePicture‬آـﻪ در 0.6.‪ VB‬وﺟـﻮد داﺷـﺘﻨﺪ، در ‪VB.NET‬‬ ‫وﺟﻮد ﻧﺪارﻧﺪ.‬ ‫)‪QBColor(color‬‬ ‫اﻳـﻦ ﺗـﺎﺑﻊ، ﺑـﺮاي ﺗﻮﻟﻴـﺪ ﺗﻌـﺪادي رﻧـﮓ از ﭘـﻴﺶ ﺗﻌﺮﻳـﻒ ﺷـﺪﻩ ﺑـﻪ آـﺎر ﻣـﻲ رود و ﻣﻘـﺪاري از ﻧـﻮع‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ‬ ‫‪ Integer‬آﻪ ﻣﻌﺮف آﺪ رﻧﮓ اﻳﺠﺎد ﺷﺪﻩ اﺳﺖ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،Color‬آﺪ رﻧﮕﻲ اﺳﺖ آﻪ ﺑﺎﻳﺪ ﺗﻮﻟﻴﺪ ﺷﻮد و ﻋﺪدي ﺑﻴﻦ 0 ﺗﺎ 51 اﺳﺖ.‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ اﻳﻦ ﺁرﮔﻮﻣﺎن ﻣﻲ ﺗﻮاﻧﺪ ﺑﭙﺬﻳﺮد، در ﺟﺪول زﻳﺮ ﺁﻣﺪﻩ اﺳﺖ:‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ color‬در ﺗﺎﺑﻊ )(‪QBColor‬‬ ‫رﻧﮓ‬ ‫ﻣﻘﺪار‬ ‫ﺳﻴﺎﻩ‬ ‫0‬ ‫ﺁﺑﻲ‬ ‫1‬ ‫ﺳﺒﺰ‬ ‫2‬ ‫ﻻﺟﻮردي‬ ‫3‬ ‫ﻗﺮﻣﺰ‬ ‫4‬ ‫ارﻏﻮاﻧﻲ‬ ‫5‬ ‫زرد‬ ‫6‬ ‫ﺳﻔﻴﺪ‬ ‫7‬ ‫ﺧﺎآﺴﺘﺮي‬ ‫8‬ ‫ﺁﺑﻲ روﺷﻦ‬ ‫9‬ ‫ﺳﺒﺰ روﺷﻦ‬ ‫01‬ ‫ﻻﺟﻮردي روﺷﻦ‬ ‫11‬ ‫ﻗﺮﻣﺰ روﺷﻦ‬ ‫21‬ ‫ارﻏﻮاﻧﻲ روﺷﻦ‬ ‫31‬ ‫زرد روﺷﻦ‬ ‫41‬ ‫ﺳﻔﻴﺪ روﺷﻦ )ﺑﺎ ﺷﺪت ﺑﺎﻻ(‬ ‫51‬ ‫آﺎرﺑﺮد اﻳﻦ ﺗﺎﺑﻊ ﺑﻴﺸﺘﺮ در ﺳﻴﺴﺘﻢ هﺎﻳﻲ اﺳﺖ آﻪ آﺎرت ﮔﺮاﻓﻴﻚ ﺁﻧﻬﺎ ﻧﺼﺐ ﻧﺸﺪﻩ ﻳﺎ ﺗﻨﻬﺎ ﻗـﺎدر ﺑـﻪ‬ ‫ﭘﺸﺘﻴﺒﺎﻧﻲ از ٦١ رﻧﮓ ﻣﻲ ﺑﺎﺷﻨﺪ آﻪ در ﺳﻴﺴﺘﻢ هﺎي ﻗﺪﻳﻤﻲ آﺎرﺑﺮد ﺑﻴﺸﺘﺮي دارد.‬ ‫)‪RGB(red,green,blue‬‬ ‫رﻧﮓ هﺎ داراي ٤ ﻣﺪل اﺻﻠﻲ هﺴﺘﻨﺪ.‬ ‫ﻣﺪل، روش ﺗﻌﺮﻳﻒ ﻳﻚ رﻧﮓ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ.‬ ‫ﻣﺪﻟﻲ آﻪ ﻣﺎﻧﻴﺘﻮر و ﺗﻠﻮﻳﺰﻳﻮن ﺧﺎﻧﻪ ي ﻣﺎ ﺟﻬﺖ ﻧﻤﺎﻳﺶ رﻧﮓ هﺎ از ﺁن اﺳﺘﻔﺎدﻩ ﻣﻲ آﻨﺪ ﻣﺪل ‪RGB‬‬ ‫ﻧﺎم دارد. در اﻳﻦ ﻣﺪل، ٣ رﻧﮓ اﺻﻠﻲ وﺟﻮد دارد آﻪ ﺑﻘﻴﻪ رﻧﮓ هﺎ از اﻳﻦ ٣ رﻧﮓ ﻣﺸﺘﻖ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫رﻧﮓ هﺎي اﻳﻦ ﻣﺪل ﻋﺒﺎرﺗﻨﺪ از: ﻗﺮﻣﺰ )‪ ،(Red‬ﺳﺒﺰ )‪ ،(Green‬ﺁﺑﻲ )‪(Blue‬‬ ‫ﻧﺎم اﻳﻦ ﻣﺪل از ﺣﺮوف اول اﻳﻦ ٣ رﻧﮓ ﮔﺮﻓﺘﻪ ﺷﺪﻩ اﺳﺖ.‬ ‫داﻣﻨﻪ ي هﺮ آﺪام از اﻳﻦ ٣ رﻧﮓ، ﻋﺪدي ﺑﻴﻦ 0 ﺗﺎ 552 اﺳﺖ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ اﻳﻦ ﺗﺎﺑﻊ، ﻗﺎدر ﺑﻪ ﺗﻮﻟﻴﺪ هﺮ ﻳﻚ از رﻧﮓ هﺎي ﻣﺪل ‪ RGB‬هﺴﺘﻴﻢ.‬ ‫ﺗﻌـــﺪاد رﻧـــﮓ هـــﺎي ﻣﻮﺟـــﻮد در ﻣـــﺪل ‪ ١٦٧٧٧٢١٦ ،RGB‬رﻧـــﮓ اﺳـــﺖ آـــﻪ از ﺿـــﺮب ٣ ﻋـــﺪد‬ ‫)652*652*652( ﺑﻪ دﺳﺖ ﻣﻲ ﺁﻳﺪ.‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ ﺗﺎﺑﻊ، ﻋﺪدي از ﻧﻮع ‪ Long‬اﺳﺖ آﻪ آﺪ رﻧﮓ ﺗﻮﻟﻴﺪ ﺷﺪﻩ را ﻧﺸﺎن ﻣﻲ دهﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٥٥‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫در ﺟﺪول زﻳﺮ، آﺪ ﺗﻌﺪادي از رﻧﮓ هﺎي ﻣﺘﺪاول را در ﻣﺪل ‪ ،RGB‬ﻣﻼﺣﻈﻪ ﻣﻲ آﻨﻴﺪ:‬ ‫آﺪ ﻣﻌﺎدل ﺗﻌﺪادي از رﻧﮓ هﺎي ﭘﺮآﺎرﺑﺮد در ﻣﺪل ‪RGB‬‬ ‫آﺪ ﭘﺎراﻣﺘﺮ ‪blue‬‬ ‫آﺪ ﭘﺎراﻣﺘﺮ ‪green‬‬ ‫آﺪ ﭘﺎراﻣﺘﺮ ‪red‬‬ ‫رﻧﮓ‬ ‫0‬ ‫0‬ ‫0‬ ‫ﺳﻴﺎﻩ‬ ‫552‬ ‫0‬ ‫0‬ ‫ﺁﺑﻲ‬ ‫0‬ ‫552‬ ‫0‬ ‫ﺳﺒﺰ‬ ‫552‬ ‫552‬ ‫0‬ ‫ﻻﺟﻮردي‬ ‫0‬ ‫0‬ ‫552‬ ‫ﻗﺮﻣﺰ‬ ‫552‬ ‫0‬ ‫552‬ ‫ارﻏﻮاﻧﻲ‬ ‫0‬ ‫552‬ ‫552‬ ‫زرد‬ ‫552‬ ‫552‬ ‫552‬ ‫ﺳﻔﻴﺪ‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل، دﺳﺘﻮر زﻳﺮ، ﻳﻚ رﻧﮓ ﻗﺮﻣﺰ ﺧﺎﻟﺺ را اﻳﺠـﺎد و ﺑـﻪ ﭘـﺲ زﻣﻴﻨـﻪ ي ﻋﻨـﺼﺮ ‪،TextBox‬‬ ‫ﻧﺴﺒﺖ ﻣﻲ دهﺪ:‬ ‫)0 ,0 ,552(‪Text1.BackColor = RGB‬‬ ‫ﻓﺮﻣﻮل ﺗﺒﺪﻳﻞ ﻣﻘﺪار ‪ RGB‬ﺑﻪ ﻣﻌﺎدل ‪:Long‬‬ ‫2 ^ 652 * ‪r + g * 256 + b‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٦٥‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)‪:(Registry‬‬ ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ رﺟﻴﺴﺘﺮي ﺳﺮ و آﺎر دارﻧﺪ‬ ‫در ‪ ،VB‬ﺗﻌﺪادي ﺗﺎﺑﻊ ﺑﺮاي ﺧﻮاﻧﺪن و ﻧﻮﺷﺘﻦ ﻣﻘﺎدﻳﺮ ﻣﺨﺘﻠﻒ در رﺟﻴﺴﺘﺮي وﻳﻨﺪوز وﺟﻮد دارد.‬ ‫)‪SaveSetting(appname, section, key, setting‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺟﻬﺖ ذﺧﻴﺮﻩ ﺳﺎزي ﻳـﻚ ﻣﻘـﺪار دﻟﺨـﻮاﻩ در رﺟﻴـﺴﺘﺮي ﻳـﺎ ﺑـﻪ هﻨﮕـﺎم آـﺮدن ﺁن ﻣﻘـﺪار از‬ ‫ﻃﺮﻳﻖ ﻧﻮﺷﺘﻦ ﺁن ﺑﺮ روي ﻣﻘﺪار ﻗﺒﻠﻲ، ﺑﻪ آﺎر ﻣﻲ رود.‬ ‫از اﻳﻦ ﺗﺎﺑﻊ ﻣﻌﻤﻮﻻ ﺑﺮاي ذﺧﻴﺮﻩ ﺗﻨﻈﻴﻤﺎت ﺑﺮﻧﺎﻣﻪ، اﺳﺘﻔﺎدﻩ ﻣﻲ ﺷﻮد.‬ ‫ﻣﻘﺎدﻳﺮ در ﻳﻚ ﻣﺴﻴﺮ اﺻﻠﻲ، ﻳﻚ ﺷﺎﺧﻪ، ﻳﻚ زﻳﺮﺷﺎﺧﻪ و در ﻧﻬﺎﻳﺖ ﺑﻪ ﺻﻮرت ﻳﻚ ﻣﻘـﺪار رﺷـﺘﻪ اي،‬ ‫در زﻳﺮﺷﺎﺧﻪ ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫ﻧﻜﺘﻪ: ﻣﺴﻴﺮ اﺻﻠﻲ ﺗﻮﺳﻂ ‪ VB‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد و ﻧﻴﺎزي ﺑﻪ وارد آﺮدن ﺁن ﻧﻴﺴﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،appname‬ﻧﺎم ﺷﺎﺧﻪ ﻳﺎ ﭘﻮﺷﻪ ي اﺻﻠﻲ اﺳﺖ آﻪ ﺗﻤﺎم زﻳﺮﭘﻮﺷﻪ هﺎ و ﻣﻘـﺎدﻳﺮ ﺁﻧﻬـﺎ در‬ ‫اﻳﻦ ﺷﺎﺧﻪ ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ. ﻣﻲ ﺗﻮاﻧﻴﺪ هﺮ ﻧﺎم دﻟﺨﻮاهﻲ ﺑﻪ اﻳﻦ ﻧﺎم ﺑﺪهﻴﺪ اﻣﺎ ﺑﺮاي راﺣﺘﻲ آـﺎر‬ ‫ﺑﻬﺘﺮ اﺳﺖ ﻧﺎم ﺑﺮﻧﺎﻣﻪ ي ﺧﻮد را در اﻳﻦ ﺁرﮔﻮﻣﺎن ذآﺮ آﻨﻴﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ section‬ﻧﻴﺰ ﻧﺎم زﻳﺮ ﺷﺎﺧﻪ اي در ﺷﺎﺧﻪ ‪ appname‬اﺳﺖ آﻪ ﻣﻘﺎدﻳﺮ ﻣﺮﺑﻮط ﺑﻪ هـﻢ در‬ ‫اﻳﻦ زﻳﺮﺷﺎﺧﻪ ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ. ﻧﺎم اﻳﻦ ﺁرﮔﻮﻣﺎن ﻧﻴﺰ دﻟﺨﻮاﻩ اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،key‬ﻧﺎم ﻣﻘﺪار و ﺁرﮔﻮﻣﺎن ‪ setting‬ﻧﻴﺰ ﺧﻮد ﻣﻘﺪاري اﺳﺖ آﻪ ﺑﺎﻳﺪ ذﺧﻴﺮﻩ ﺷﻮد.‬ ‫اﮔﺮ ﻣﻘﺪار ‪ setting‬ﺑﻪ هﺮ دﻟﻴﻠﻲ ذﺧﻴﺮﻩ ﻧﺸﻮد، ﻳﻚ ﺧﻄﺎي زﻣﺎن اﺟﺮا در ﺑﺮﻧﺎﻣﻪ اﺗﻔﺎق ﻣﻲ اﻓﺘﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻓﺮض آﻨﻴﺪ آﻪ ﻣﻘﺪار ﻃﻮل و ﻋﺮض ﻓﺮم ﺑﺮﻧﺎﻣﻪ ي ﻣﺎ، ﺗﻮﺳﻂ آـﺎرﺑﺮ در زﻣـﺎن اﺟـﺮاي‬ ‫ﺑﺮﻧﺎﻣﻪ ﺗﻐﻴﻴﺮ ﭘﻴﺪا آﻨﺪ و ﺑﺨﻮاهﻴﻢ دﻓﻌﻪ ي ﺑﻌﺪ آﻪ ﺑﺮﻧﺎﻣﻪ ﺗﻮﺳﻂ آﺎرﺑﺮ اﺟﺮا ﻣﻲ ﺷﻮد، ﻓﺮم ﺑـﺎ ﻃـﻮل‬ ‫و ﻋﺮض ﺟﺪﻳﺪ )ﻳﻌﻨﻲ هﻤﺎن اﻧﺪاز هﺎي ﺗﻐﻴﻴﺮ ﭘﻴﺪا آﺮدﻩ ﺗﻮﺳﻂ آﺎرﺑﺮ( ﻧﻤﺎﻳﺶ دادﻩ ﺷﻮد.‬ ‫دﺳﺘﻮرات زﻳﺮ، ﻣﻘﺪار ﻃﻮل و ﻋﺮض ﺗﻐﻴﻴﺮ ﻳﺎﻓﺘﻪ ي ﻓﺮم را در رﺟﻴﺴﺘﺮي ذﺧﻴﺮﻩ ﻣﻲ آﻨﻨﺪ:‬ ‫)‪SaveSetting(“MyApp”, “Startup”, “Height”,Me.Height‬‬ ‫)‪SaveSetting(“MyApp”, “Startup”, “Width”,Me.Width‬‬ ‫دﻗﺖ آﻨﻴﺪ آﻪ ﺑﻨﺪﻩ ﺟﻬﺖ راﺣﺘﻲ آﺎر، ﻣﻘﺪار ٣ ﭘﺎراﻣﺘﺮ اول اﻳـﻦ دﺳـﺘﻮرات را ﻣﺘﻨﺎﺳـﺐ ﺑـﺎ ﻣﻘـﺪاري‬ ‫آﻪ ﻗﺮار اﺳﺖ ذﺧﻴﺮﻩ ﺷﻮد اﻧﺘﺨﺎب آﺮدم.‬ ‫ﻧﻜﺘﻪ: ﻣﻨﺎﺳﺐ ﺗﺮﻳﻦ ﻣﻜﺎن ﺑﺮاي ﻧﻮﺷﺘﻦ اﻳﻦ آﺪهﺎ، زﻣﺎﻧﻲ اﺳﺖ آﻪ ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﭘﺎﻳـﺎن ﻣـﻲ ﭘـﺬﻳﺮد‬ ‫و ﻣﻨﺎﺳﺒﺘﺮﻳﻦ زﻣﺎن ﺟﻬﺖ ﻓﺮاﺧﻮاﻧﻲ ﺁﻧﻬﺎ، زﻣﺎﻧﻲ اﺳﺖ آﻪ ﺑﺮﻧﺎﻣﻪ ﺁﻏﺎز ﻣـﻲ ﺷـﻮد. )ﺑـﺎ اﺳـﺘﻔﺎدﻩ از‬ ‫ﺗﺎﺑﻊ ‪ GetSetting‬آﻪ در اداﻣﻪ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻩ اﺳﺖ(‬ ‫)] ‪DeleteSetting(appname,section [,key‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ دﻗﻴﻘﺎ ﻋﻜﺲ ﺗﺎﺑﻊ )(‪ SaveSetting‬ﻋﻤﻞ آﺮدﻩ و ﻳﻚ ﻣﻘﺪار از زﻳﺮﺷﺎﺧﻪ ﻳﺎ آـﻞ زﻳﺮﺷـﺎﺧﻪ‬ ‫را از رﺟﻴﺴﺘﺮي ﺧﺬف ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن هﺎي اﻳﻦ ﺗﺎﺑﻊ، هﻤﺎن ﺁرﮔﻮﻣﺎن هﺎي ﺗﺎﺑﻊ )(‪ SaveSetting‬هﺴﺘﻨﺪ.‬ ‫اﮔـﺮ از ذآـﺮ ﺁرﮔﻮﻣـﺎن اﺧﺘﻴـﺎري ‪ key‬ﺧـﻮدداري ﺷـﻮد، ﺗﻤـﺎﻣﻲ ﻣﻘـﺎدﻳﺮ ﻣﻮﺟـﻮد در زﻳﺮﺷـﺎﺧﻪ ﺣـﺬف‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻣﻲ ﺧﻮاهﻴﻢ ﻣﻘﺎدﻳﺮي را آﻪ در ﻣﺜﺎل ﺗﺎﺑﻊ )(‪ SaveSetting‬در رﺟﻴـﺴﺘﺮي ذﺧﻴـﺮﻩ‬ ‫آﺮدﻳﻢ، ﺣﺬف آﻨﻴﻢ. ﭘﺲ دﺳﺘﻮرات زﻳﺮ را ﻣﻲ ﻧﻮﻳﺴﻴﻢ:‬ ‫)”‪DeleteSetting(“MyApp”, “Startup”, “Height‬‬ ‫)”‪DeleteSetting(“MyApp”, “Startup”, “Width‬‬ ‫ﻣﻲ ﺗﻮاﻧﻴﺪ اﻳﻦ دﺳﺘﻮرات را در ﻳﻚ ﺧﻂ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺧﻼﺻﻪ آﻨﻴﺪ:‬ ‫)”‪DeleteSetting(“MyApp”, Startup‬‬ ‫دﻗﺖ آﻨﻴﺪ اﮔﺮ ﻣﻘﺎدﻳﺮ دﻳﮕﺮي ﻧﻴﺰ در زﻳﺮﺷﺎﺧﻪ ي ‪ Startup‬وﺟﻮد داﺷـﺘﻪ ﺑﺎﺷـﻨﺪ، ﺁﻧﻬـﺎ ﻧﻴـﺰ ﺣـﺬف‬ ‫ﻣﻲ ﺷﻮﻧﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٧٥‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)] ‪GetSetting(appname,section,key [,default‬‬ ‫وﻗﺘﻲ آﻪ ﻣﻘﺎدﻳﺮ در رﺟﻴﺴﺘﺮي ﻧﻮﺷﺘﻪ ﺷﺪ ﻃﺒﻌﺎ ﺑﺎﻳﺪ ﺁﻧﻬﺎ را ﺧﻮاﻧﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻣﻘﺪار ذﺧﻴﺮﻩ ﺷﺪﻩ ي آﺎرﺑﺮ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫٣ ﺁرﮔﻮﻣﺎن اول اﻳﻦ ﺗﺎﺑﻊ هﻤﺎن ﭘﺎراﻣﺘﺮهﺎي ﺗﻮاﺑﻊ )(‪ SaveSetting‬و )(‪ DeleteSetting‬هـﺴﺘﻨﺪ‬ ‫آﻪ ﻣﺴﻴﺮ ذﺧﻴﺮﻩ دادﻩ در رﺟﻴﺴﺘﺮي را ﻣﺸﺨﺺ ﻣﻲ آﻨﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،default‬ﻣﻘﺪاري ﭘـﻴﺶ ﻓـﺮض اﺳـﺖ آـﻪ در ﺻـﻮرت ﻧﺒـﻮدن ﻣﻘـﺪاري در ﻣـﺴﻴﺮ‬ ‫ذآﺮﺷﺪﻩ، ﺗﻮﺳﻂ ﺗﺎﺑﻊ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻣﻲ ﺧﻮاهﻴﻢ ﻣﻘﺎدﻳﺮي را آﻪ در ﻣﺜﺎل ﺗﺎﺑﻊ )(‪ SaveSetting‬در رﺟﻴـﺴﺘﺮي ذﺧﻴـﺮﻩ‬ ‫آﺮدﻳﻢ، ﺑﻪ دﺳﺖ ﺁوردﻩ و ﻃﻮل و ﻋﺮض ﺟﺪﻳﺪ ﻓﺮم را در هﻨﮕﺎم اﺟﺮاي ﺑﺮﻧﺎﻣﻪ ﺗﻌﻴﻴﻦ آﻨﻴﻢ:‬ ‫)0001 ,”‪Me.Height =GetSetting(“MyApp”, “Startup”, “Height‬‬ ‫)0051 ,”‪Me.Width =GetSetting(“MyApp”, “Startup”, “Width‬‬ ‫در اﻳﻦ دﺳﺘﻮرات ﺣﺘﻤﺎ ﺑﺎﻳﺪ ﻣﻘﺪار ﺁرﮔﻮﻣﺎن ‪ default‬را ذآﺮ آﻨﻴﺪ ﭼـﻮن در ﺻـﻮرﺗﻲ آـﻪ ﻣﻘـﺪاري در‬ ‫رﺟﻴﺴﺘﺮي وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ، ﻓﺮم ﻣﻤﻜﻦ اﺳﺖ ﺑﺎ ﺳﺎﻳﺰي ﺑﺴﻴﺎر آﻮﭼﻚ ﻳﺎ ﺑـﺴﻴﺎر ﺑـﺰرگ ﻇـﺎهﺮ‬ ‫ﺷﻮد.‬ ‫)‪GetAllSettings(appname,section‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻟﻴﺴﺘﻲ از ﺗﻤﺎﻣﻲ ﻣﻘﺎدﻳﺮ ﻣﻮﺟﻮد در زﻳﺮﺷـﺎﺧﻪ ﺗﻌﻴـﻴﻦ ﺷـﺪﻩ را ﺑـﺎ ﻗـﺮار دادن ﺁﻧﻬـﺎ در ﻳـﻚ‬ ‫ﺁراﻳﻪ ي دو ﺑﻌﺪي ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن هﺎي ‪ appname‬و ‪ section‬ﻗﺒﻼ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻧﺪ.‬ ‫ﺧﺎﻧﻪ ي )0,0( ﺁراﻳﻪ، ﻧﺎم اوﻟﻴﻦ ﻣﻘﺪار زﻳﺮﺷـﺎﺧﻪ و ﺧﺎﻧـﻪ ي )1,0( ﺁراﻳـﻪ، ﻣﻘـﺪار ﺁن را در ﺧـﻮد ﻧﮕـﻪ‬ ‫ﻣﻲ دارد.‬ ‫ﺧﺎﻧﻪ ي )0,1( ﺁراﻳﻪ، ﻧﺎم دوﻣﻴﻦ ﻣﻘﺪار زﻳﺮﺷﺎﺧﻪ و ﺧﺎﻧﻪ ي )1,1( ﺁراﻳﻪ، ﻣﻘﺪار ﺁن را ﻧﮕﻬﺪاري ﻣـﻲ‬ ‫آﻨﺪ و ﺑﻪ هﻤﻴﻦ ﺗﺮﺗﻴﺐ…‬ ‫ﻧﻜﺘﻪ: ﺑﺮاي ﺁﮔﺎهﻲ از ﺗﻌﺪاد ﻣﻘﺎدﻳﺮ ذﺧﻴﺮﻩ ﺷﺪﻩ در ﺁراﻳﻪ ﻳﺎ ﺑﻪ ﻋﺒﺎرت ﺑﻬﺘﺮ ﺗﻌﺪاد ﻣﻘـﺎدﻳﺮ ﻣﻮﺟـﻮد در‬ ‫زﻳﺮﺷﺎﺧﻪ، از ﺧﺎﺻﻴﺖ ‪ Length‬ﺁراﻳﻪ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﻓﺮض ﻣﻲ آﻨﻴﻢ ﺁراﻳﻪ ‪ AllSettings‬ﺑﻪ ﻋﻨﻮان ﻳﻚ ﺁراﻳﻪ دو ﺑﻌﺪي ﻣﻌﺮﻓﻲ ﺷﺪﻩ اﺳﺖ.‬ ‫دﺳ ـﺘﻮر زﻳــﺮ، ﺗﻤــﺎﻣﻲ ﻣﻘــﺎدﻳﺮ ﻣﻮﺟــﻮد در زﻳــﺮ ﺷــﺎﺧﻪ ي ‪ Startup‬از ﺷــﺎﺧﻪ ‪ MyApp‬را در ﺁراﻳــﻪ‬ ‫ـ‬ ‫‪ AllSettings‬ﻗﺮار ﻣﻲ دهﺪ.‬ ‫)”‪AllSettings = GetAllSettings(“MyApp”, “Startup‬‬ ‫ﺣﺎﻻ ﻣﻲ ﺗﻮاﻧﻴﻢ ﺑﺎ دﺳﺘﻮرات زﻳﺮ، ﺗﻤﺎﻣﻲ ﻣﻘﺎدﻳﺮ ﻣﻮﺟﻮد در زﻳﺮﺷﺎﺧﻪ را آـﻪ در ﺁراﻳـﻪ ذﺧﻴـﺮﻩ ﺷـﺪﻩ‬ ‫اﻧﺪ را ﺑﺒﻴﻨﻴﻢ:‬ ‫)0(‪For i =0 To AllSettings.GetUpperBound‬‬ ‫))1,‪Console.WriteLine(AllSettings(i,0) & “ = “ & AllSettings(i‬‬ ‫‪Next‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٨٥‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)‪:(Application Collaboration‬‬ ‫ﺗﻮاﺑﻊ آﺎرﺑﺮدي‬ ‫)] ‪Shell(path_name [,style ][,wait ][,timeout‬‬ ‫ﺑﺎ اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ، ﻗﺎدر ﺑﻪ اﺟﺮاي ﻳﻚ ﺑﺮﻧﺎﻣﻪ دﻳﮕﺮ از درون ﺑﺮﻧﺎﻣﻪ ي ﺧﻮد هﺴﺘﻴﺪ.‬ ‫در ﺻﻮرﺗﻲ آﻪ اﻳﻦ ﺗﺎﺑﻊ آﺎر ﺧﻮد را ﺑﺎ ﻣﻮﻓﻘﻴﺖ اﻧﺠﺎم دهﺪ، هﻨﺪل ﺑﺮﻧﺎﻣﻪ ي اﺟﺮا ﺷﺪﻩ را آﻪ ﺗﻮﺳـﻂ‬ ‫ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ در ﻏﻴﺮ اﻳﻨﺼﻮرت، ﻣﻘﺪار ﺻﻔﺮ را ﺑﺮﮔـﺸﺖ ﻣـﻲ‬ ‫دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،path_name‬ﻣﺴﻴﺮ و ﻧﺎم ﻓﺎﻳﻠﻲ اﺳﺖ آﻪ ﻣﻲ ﺧﻮاهﻴﻢ اﺟﺮا ﺷﻮد. اﮔـﺮ ﻓﺎﻳـﻞ اﺟﺮاﻳـﻲ‬ ‫ﻧﻴﺎز ﺑﻪ ﺁرﮔﻮﻣﺎن هﺎﻳﻲ هﻤﺎﻧﻨﺪ ‪ command‬هﺎي ﻣﺨﺼﻮص ﺧﻮد داﺷﺖ، ﻣﻲ ﺗﻮان ﻧـﺎم ﺁﻧﻬـﺎ را ﻧﻴـﺰ‬ ‫در اداﻣﻪ ﻣﺴﻴﺮ ﻓﺎﻳﻞ ذآﺮ آﺮد آﻪ اﻳﻦ ﻣﻮرد ﻣﻌﻤﻮﻻ ﻧﺪرﺗﺎ وﺟﻮد دارد.‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: اﻳﻦ ﺗﺎﺑﻊ ﺗﻨﻬﺎ ﻓﺎﻳﻞ هﺎي اﺟﺮاﻳﻲ را اﺟﺮا ﻣﻲ آﻨﺪ اﻣـﺎ ﻣـﻲ ﺗـﻮان ﺑـﺎ ﻧـﺴﺒﺖ دادن ﻧـﺎم و‬ ‫ﻣﺴﻴﺮ ﻓﺎﻳﻠﻲ دﻳﮕﺮ در اداﻣﻪ ﻧﺎم و ﻣﺴﻴﺮ ﻓﺎﻳﻞ اﺻﻠﻲ، در ﺻﻮرﺗﻲ آﻪ اﻳﻦ ﻓﺎﻳﻞ ﺑﺎ ﺑﺮﻧﺎﻣـﻪ ﻣـﻮرد ﻧﻈـﺮ‬ ‫ﻣﺎ ﻗﺎﺑﻞ اﺟﺮا ﺑﺎﺷﺪ، ﺁن را اﺟﺮا آﺮد ﻣﺜﻼ ﻳﻚ ﻓﺎﻳﻞ ﺑﺎ ﭘﺴﻮﻧﺪ ‪ TXT‬را ﻣـﻲ ﺗـﻮان ﺑـﺎ دﺳـﺘﻮر زﻳـﺮ اﺟـﺮا‬ ‫آﺮد:‬ ‫)‪NTXT=Shell(“notepad.exe C:MyFile.txt”, AppWinStyle.NormalFocus‬‬ ‫اﻳﻦ دﺳﺘﻮر، ﻓﺎﻳﻞ ‪ MyFile.txt‬را ﺑﻪ وﺳﻴﻠﻪ ﺑﺮﻧﺎﻣﻪ ‪ Notepad‬ﺑﺎز ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،style‬وﺿﻌﻴﺖ ﻓﺮم ﺑﺮﻧﺎﻣﻪ اي آﻪ اﺟـﺮا ﺧﻮاهـﺪ ﺷـﺪ را ﻣﻌـﻴﻦ ﻣـﻲ آﻨـﺪ و ﻣـﻲ‬ ‫ﺗﻮاﻧﺪ ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ زﻳﺮ را ﺑﭙﺬﻳﺮد:‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ Style‬در ﺗﺎﺑﻊ )(‪Shell‬‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻣﻘﺪار‬ ‫ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت ﻣﺨﻔﻲ اﺟﺮا ﻣﻲ ﺷﻮد اﻣﺎ ﺑﻪ ﻋﻨـﻮان ﺑﺮﻧﺎﻣـﻪ ﻓﻌـﺎل‬ ‫‪Hide‬‬ ‫در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮل و ﺑـﺎ اﻧـﺪازﻩ ﺧـﻮدش اﺟـﺮا ﻣـﻲ ﺷـﻮد و ﺑـﻪ‬ ‫‪NormalFocus‬‬ ‫ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌﺎل در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت ﻣﻴﻨﻴﻤﺎﻳﺰ اﺟﺮا ﺧﻮاهﺪ ﺷﺪ و ﺑﻪ ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌـﺎل‬ ‫‪MinimizedFocus‬‬ ‫در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت ﺗﻤﺎم ﺻـﻔﺤﻪ اﺟـﺮا ﻣـﻲ ﺷـﻮد و ﺑـﻪ ﻋﻨـﻮان ﺑﺮﻧﺎﻣـﻪ‬ ‫‪MaximizedFocus‬‬ ‫ﻓﻌﺎل در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮل و ﺑﺎ اﻧﺪازﻩ ﺧﻮدش اﺟﺮا ﻣـﻲ ﺷـﻮد اﻣـﺎ ﺑـﻪ‬ ‫‪NormalNoFocus‬‬ ‫ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌﺎل در ﻧﻈﺮ ﮔﺮﻓﺘـﻪ ﻧﻤـﻲ ﺷـﻮد و ﺑﺮﻧﺎﻣـﻪ اي آـﻪ ﺑـﻪ‬ ‫ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌﺎل اﺳﺖ، ﻓﻌﺎل ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ.‬ ‫‪ MinimizedNoFocus‬ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت ﻣﻴﻨﻴﻤﺎﻳﺰ اﺟﺮا ﻣﻲ ﺷﻮد اﻣﺎ ﺑﻪ ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌـﺎل‬ ‫در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻧﻤﻲ ﺷﻮد و ﺑﺮﻧﺎﻣـﻪ اي آـﻪ ﺑـﻪ ﻋﻨـﻮان ﺑﺮﻧﺎﻣـﻪ ﻓﻌـﺎل‬ ‫اﺳﺖ، ﻓﻌﺎل ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ wait‬ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ ﺁﻳﺎ ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﺑﺮاي اﺟﺮاي آﺎﻣﻞ ﺑﺮﻧﺎﻣﻪ اي آﻪ ﻓﺮاﺧـﻮاﻧﻲ‬ ‫ﺧﻮاهﺪ ﺷﺪ ﺻﺒﺮ آﻨﺪ ﻳﻌﻨﻲ دﺳﺘﻮرات ﺑﻌـﺪ از ﺗـﺎﺑﻊ )(‪ ،Shell‬ﭘـﺲ از ﻓﺮاﺧـﻮاﻧﻲ ﺑﺮﻧﺎﻣـﻪ ﻣـﻮرد ﻧﻈـﺮ‬ ‫اﺟﺮا ﺷﻮﻧﺪ ﻳﺎ ﺑﻼﻓﺎﺻﻠﻪ.‬ ‫ﺑﻪ ﻋﺒﺎرت ﺳﺎدﻩ ﺗﺮ، ﺗﻌﻴﻴﻦ ﻣﻲ آﻨـﺪ آـﻪ ﻗﺒـﻞ از اﺟـﺮاي ﺗﻤـﺎﻣﻲ دﺳـﺘﻮرات ﺑﻌـﺪ از ﺗـﺎﺑﻊ )(‪،Shell‬‬ ‫ﺑﺮﻧﺎﻣﻪ اﺟﺮا ﺷﻮد ﻳﺎ در هﻤﺎن زﻣﺎن ﻓﺮاﺧﻮاﻧﻲ.‬ ‫اﻳﻦ ﭘﺎراﻣﺘﺮ، ﻣﻘﺪار ‪ True‬ﻳـﺎ ‪ False‬را ﻣـﻲ ﭘـﺬﻳﺮد آـﻪ ﺑـﻪ ﻃـﻮر ﭘـﻴﺶ ﻓـﺮض، ‪ False‬اﺳـﺖ ﻳﻌﻨـﻲ‬ ‫ﺑﺮﻧﺎﻣﻪ اي آﻪ ﻗﺮار اﺳﺖ اﺟﺮا ﺷﻮد ﺑﺎﻳﺪ ﺻﺒﺮ آﻨﺪ ﺗـﺎ ﺗﻤـﺎﻣﻲ دﺳـﺘﻮرات ﺑﻌـﺪ از ﺗـﺎﺑﻊ )(‪ shell‬اﺟـﺮا‬ ‫ﺷﻮﻧﺪ.‬ ‫ﺁﺧﺮﻳﻦ ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري آﻪ ‪ timeout‬ﻧﺎم دارد، ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ ﭘﺲ از ﭼﻨـﺪ ﺛﺎﻧﻴـﻪ ﺑﺮﻧﺎﻣـﻪ اي آـﻪ‬ ‫ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ ﺷﻮد ﺑﺎﻳﺪ اﺟﺮا ﺷﻮد.‬ ‫اﻳﻦ ﻣﻘﺪار، ﻋﺪدي ﺑﺮ ﺣﺴﺐ ﻣﻴﻠﻲ ﺛﺎﻧﻴﻪ اﺳﺖ و هﺮ ٠٠٠١ ﻣﻴﻠﻲ ﺛﺎﻧﻴﻪ، ١ ﺛﺎﻧﻴﻪ اﺳﺖ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٩٥‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﻣﻘﺪار اﻳﻦ ﺁرﮔﻮﻣﺎن، 1- اﺳﺖ ﻳﻌﻨﻲ ﺑﺪون وﻗﻔـﻪ و ﺑﻼﻓﺎﺻـﻠﻪ ﭘـﺲ از ﻓﺮاﺧـﻮاﻧﻲ‬ ‫اﺟﺮا ﻣﻲ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل، ﺑﺮاي اﺟﺮاي ﺑﺮﻧﺎﻣﻪ ‪ Notepad‬وﻳﻨﺪوز از دﺳﺘﻮر زﻳﺮ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ:‬ ‫)‪NPAD = Shell(“notepad.exe”, AppWinStyle.NormalFocus‬‬ ‫ﺗﻮﺟﻪ: ﺑﺮاي اﺟﺮاي ﺑﺮﻧﺎﻣﻪ هﺎﻳﻲ آﻪ در ﭘﻮﺷﻪ اﺻﻠﻲ وﻳﻨﺪوز هـﺴﺘﻨﺪ، ﻧﻴـﺎزي ﺑـﻪ ذآـﺮ ﻣـﺴﻴﺮ ﺁﻧﻬـﺎ‬ ‫ﻧﻴﺴﺖ و ﺗﻨﻬﺎ ﺁوردن ﻧﺎم، آﻔﺎﻳﺖ ﻣﻲ آﻨﺪ.‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: ﺗﺎﺑﻊ )(‪ SendKeys‬در ‪ VB.NET‬وﺟﻮد ﻧﺪارد.‬ ‫)] ‪AppActivate(title [,wait‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ )آﻪ ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ ﻧﺪارد( ﺑﻪ ﺷﻤﺎ اﺟﺎزﻩ ﻣـﻲ دهـﺪ ﺑﺮﻧﺎﻣـﻪ اي را آـﻪ ﻗـﺒﻼ ﺗﻮﺳـﻂ ﺗـﺎﺑﻊ‬ ‫)(‪ Shell‬ﻓﺮاﺧﻮاﻧﻲ و اﺟﺮا آﺮدﻩ اﻳﺪ، ﺑﻪ ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌﺎل )ﭘﻨﺠﺮﻩ ﻓﻌﺎل( ﺳﻴﺴﺘﻢ ﻋﺎﻣـﻞ ﻣﻌﺮﻓـﻲ‬ ‫آﻨﻴﺪ.‬ ‫در ﺁرﮔﻮﻣﺎن ‪ ،title‬آﻪ ﻣﻘﺪاري از ﻧﻮع رﺷﺘﻪ اي اﺳﺖ ﺑﺎﻳﺪ ﻧﺎم ﻧﻮار ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ اي آﻪ ﻗـﺼﺪ ﻓﻌـﺎل‬ ‫ﺷﺪن ﺁن را دارﻳﺪ ذآﺮ آﻨﻴﺪ. ﻣﺜﻼ: "‪“Untitled – Notepad‬‬ ‫در اﻳﻦ ﺁرﮔﻮﻣﺎن هﻤﭽﻨﻴﻦ ﺑﺎ ذآﺮ آﺮدن ﻣﻘﺪاري آﻪ ﺗـﺎﺑﻊ )(‪ Shell‬در ﻣﺘﻐﻴـﺮ ﻓﺮاﺧـﻮاﻧﻲ آﻨﻨـﺪﻩ ﺧـﻮد‬ ‫ﻗﺮار ﻣﻲ دهﺪ، ﻗﺎدر ﺑﻪ ﻓﻌﺎل آﺮدن ﺑﺮﻧﺎﻣﻪ هﺴﺘﻴﺪ. ﻣﺜﻼ در ﺁﺧﺮﻳﻦ ﻣﺜـﺎل ﺗﻮﺿـﻴﺤﺎت ﺗـﺎﺑﻊ )(‪،Shell‬‬ ‫ﻣﻲ ﺗﻮاﻧﻴﺪ ﻧﺎم ﻣﺘﻐﻴﺮ ‪ NPAD‬را در ﺁرﮔﻮﻣﺎن ‪ title‬اﻳﻦ ﺗﺎﺑﻊ ذآﺮ آﻨﻴﺪ.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ wait‬ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ ﺁﻳﺎ ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﺑﺎﻳـﺪ ﺑـﻪ ﻋﻨـﻮان ﺑﺮﻧﺎﻣـﻪ ﻓﻌـﺎل ﺑﺎﺷـﺪ ﺗـﺎ‬ ‫ﺑﺘﻮاﻧﺪ ﺑﺮﻧﺎﻣﻪ دﻳﮕﺮي را ﺑﺎ اﻳﻦ ﺗﺎﺑﻊ ﻓﻌﺎل آﻨﺪ ﻳﺎ ﺧﻴﺮ.‬ ‫اﻳﻦ ﭘﺎراﻣﺘﺮ، ﻣﻘﺪار ‪ True‬ﻳﺎ ‪ False‬را ﻣﻲ ﭘﺬﻳﺮد. ﻣﻘﺪار ﭘﻴﺶ ﻓﺮض، ‪ False‬اﺳﺖ ﻳﻌﻨـﻲ ﺣﺘـﻲ در‬ ‫ﺻﻮرت ﻓﻌﺎل ﻧﺒﻮدن ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﻧﻴﺰ، ﺑﺮﻧﺎﻣﻪ درﺧﻮاﺳﺘﻲ ﺑﻪ ﺳﺮﻋﺖ ﻓﻌﺎل ﻣﻲ ﺷﻮد.‬ ‫در ﺻﻮرﺗﻲ آﻪ ‪ True‬ﺑﺎﺷﺪ، ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﺑﺎﻳﺪ ﺻﺒﺮ آﻨﺪ ﺗﺎ ﻓﻌـﺎل ﺷـﻮد ﻳـﺎ اﺻـﻄﻼﺣﺎ ﻓﻮآـﺎس ﺑـﻪ ﺁن‬ ‫اﻧﺘﻘﺎل ﭘﻴﺪا آﻨﺪ ﺗﺎ ﺑﺘﻮاﻧﺪ ﺑﺮﻧﺎﻣﻪ دﻳﮕﺮي را ﻓﻌﺎل آﻨﺪ.‬ ‫ﺗﻮﺟﻪ: اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﻣﻴﻨﻴﻤﺎﻳﺰ ﺑﻮدن ﻳﺎ اﻧﺪازﻩ ي ﭘﻨﺠﺮﻩ هﺎ آﺎري ﻧﺪارد و ﻣﺜﻼ اﮔـﺮ ﺑﺮﻧﺎﻣـﻪ اي ﻣﻴﻨﻴﻤـﺎﻳﺰ‬ ‫ﺑﺎﺷﺪ، ﺁن را در هﻤﺎن ﺣﺎﻟﺖ ﻣﻴﻨﻴﻤﺎﻳﺰ ﺑﻪ ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌﺎل در ﻧﻈﺮ ﻣﻲ ﮔﻴﺮد.‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: هﻤﻴﺸﻪ ﺳﻌﻲ آﻨﻴﺪ اﺑﺘﺪا ﺑﺮﻧﺎﻣﻪ ﻣﻮرد ﻧﻈﺮ را ﺑﺎ ﺗﺎﺑﻊ )(‪ Shell‬اﺟـﺮا و ﺳـﭙﺲ ﻣﺘﻐﻴـﺮي‬ ‫آﻪ ﺗﺎﺑﻊ )(‪ Shell‬را در ﺁن ﻗﺮار دادﻩ اﻳﺪ در ﺁرﮔﻮﻣﺎن ‪ title‬اﻳﻦ ﺗﺎﺑﻊ ﻗﺮار دادﻩ و اﻗﺪام ﺑﻪ ﻓﻌـﺎل آـﺮدن‬ ‫ﺁن آﻨﻴﺪ. ﻣﺜﻼ ﻓﺮض آﻨﻴﺪ آﻪ ﺑﺮﻧﺎﻣﻪ ‪ Notepad‬را ٢ ﺑﺎر اﺟﺮا آﺮدﻩ اﻳـﺪ و ﻋﻨـﻮان ﻧـﻮار هـﺮ دو ﭘﻨﭽـﺮﻩ‬ ‫‪ ،Notepad‬ﻳﻜﻲ اﺳﺖ. در اﻳﻦ ﺣﺎﻟﺖ اﮔﺮ ﻧﺎم ﻧﻮار ﻋﻨﻮان را در ﺗـﺎﺑﻊ )(‪ AppActivate‬ذآـﺮ آﻨﻴـﺪ،‬ ‫ﺁن ﻳﻜﻲ آﻪ ﺁﺧﺮ اﺟﺮا ﺷﺪﻩ اﺳﺖ ﺑﻪ ﻋﻨﻮان ﭘﻨﺠﺮﻩ ﻓﻌﺎل در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد آـﻪ ﻣﻤﻜـﻦ اﺳـﺖ‬ ‫دﻟﺨﻮاﻩ ﺷﻤﺎ ﻧﺒﺎﺷﺪ.‬ ‫دﺳﺘﻮرات اﺧﺘﻴﺎري )‪:(Option Statements‬‬ ‫دﺳﺘﻮرات ‪ Option‬ﻳﺎ اﺧﺘﻴﺎري، ﺳﻬﻮﻟﺖ آﺎر در آﺪﻧﻮﻳﺴﻲ را ﺑﺮاي ﺷﻤﺎ ﻓﺮاهﻢ ﻣﻲ آﻨﻨﺪ.‬ ‫اﻳﻦ دﺳﺘﻮرات در اﺑﺘﺪاي آﺪ ﻓﺮم ﻳﺎ ﻣـﺎژول ﻧﻮﺷـﺘﻪ ﻣـﻲ ﺷـﻮﻧﺪ و در ﺗﻤـﺎم ﺁن ﻓـﺮم ﻳـﺎ ﻣـﺎژول ﻗﺎﺑـﻞ‬ ‫دﺳﺘﺮﺳﻲ هﺴﺘﻨﺪ. اﻳﻦ دﺳﺘﻮرات را در زﻳﺮ ﻣﺸﺎهﺪﻩ ﻣﻲ آﻨﻴﺪ:‬ ‫‪Option Compare‬‬ ‫اﻳﻦ دﺳﺘﻮر ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ ‪ VB‬ﭼﮕﻮﻧﻪ ﻋﻤﻠﻴﺎت ﻣﻘﺎﻳﺴﻪ اي رﺷﺘﻪ هﺎ را اﻧﺠﺎم دهﺪ.‬ ‫ﻣﻘﺎﻳﺴﻪ ي رﺷﺘﻪ اي ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ ﻃﻮر ﻣﻌﻤﻮل ﻳﺎ ﺑﺎ در ﻧﻈﺮ ﮔﺮﻓﺘﻦ ﺑـﺰرگ ﻳـﺎ آﻮﭼـﻚ ﺑـﻮدن ﺣـﺮوف‬ ‫اﻧﺠﺎم ﺷﻮد.‬ ‫ﻣﻘﺎﻳﺴﻪ رﺷﺘﻪ اي ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ ﻳﻜﻲ از دو ﺷﻜﻞ زﻳﺮ ﺻﻮرت ﭘﺬﻳﺮد:‬ ‫‪ :Option Compare Binary‬در اﻳــﻦ ﻧــﻮع ﻣﻘﺎﻳــﺴﻪ آــﻪ ﺑــﻪ ﺻــﻮرت ﺑــﺎﻳﻨﺮي اﻧﺠــﺎم ﻣــﻲ ﺷــﻮد،‬ ‫آﺎراآﺘﺮهﺎي ﺑﺰرگ ﺑﺮ آﺎراآﺘﺮهﺎي آﻮﭼﻚ ارﺟﻌﻴﺖ دارﻧـﺪ و آﺎراآﺘﺮهـﺎي ‪ Symbol‬ﻳـﺎ ﻧﻤـﺎد در اﻧﺘﻬـﺎ‬ ‫ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ. ﻣﺜﻼ ﺑﻪ ﺷﻜﻞ زﻳﺮ:‬ ‫^‪A < B < C… < Z < a < b < c… < z < A’ < A^ < a’ < a‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٠٦‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫‪ :Option Compare Text‬در اﻳﻦ ﻧﻮع ﻣﻘﺎﻳﺴﻪ، ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ ﺑـﺎ ﺗﻮﺟـﻪ ﺑـﻪ ﺑـﺰرگ و آﻮﭼـﻚ ﺑـﻮدن‬ ‫ﺣﺮوف اﻧﺠﺎم ﻣﻲ ﺷﻮد. اﻳﻦ ﻧﻮع ﻣﻘﺎﻳﺴﻪ، ﻣﻘﺎﻳﺴﻪ ﭘﻴﺶ ﻓﺮض رﺷﺘﻪ هﺎ اﺳﺖ. ﻣﺜﻼ:‬ ‫‪A=a < A'=a' < B=b‬‬ ‫‪Option Explicit‬‬ ‫هﻤﺎن ﻃﻮر آﻪ ﻣﻲ داﻧﻴﺪ، در ‪ VB‬ﻣﻲ ﺗﻮان ﻳﻚ ﻣﺘﻐﻴﺮ را ﺑﺪون ﺗﻌﺮﻳﻒ آﺮدن ﺁن ﺑﻪ آﺎر ﺑﺮد.‬ ‫ﻣﻲ ﺗﻮان ﺑﺎ اﺳﺘﻔﺎدﻩ از اﻳﻦ دﺳﺘﻮر ﺑﻪ آﺎﻣﭙﺎﻳﻠﺮ وﻳﮋوال ﺑﻴﺴﻴﻚ ﮔﻔﺖ آﻪ از ﺗﻌﺮﻳـﻒ ﻧﻜـﺮدن ﻣﺘﻐﻴﺮهـﺎ‬ ‫در ﻃﻮل ﻓﺮم ﻳﺎ ﻣﺎژوﻟﻲ آﻪ اي دﺳﺘﻮر ﻗﺮار ﻣﻲ ﮔﻴﺮد، ﺟﻠﻮﮔﻴﺮي آﻨﺪ.‬ ‫در اﻳﻦ ﺣﺎﻟﺖ، در زﻣﺎن اﺟﺮاي ﺑﺮﻧﺎﻣﻪ آﺎﻣﭙﺎﻳﻠﺮ ‪ VB‬ﺗﻤـﺎﻣﻲ ﻣﺘﻐﻴﺮهـﺎ را از ﻟﺤـﺎظ ﺗﻌﺮﻳـﻒ ﺷـﺪن ﭼـﻚ‬ ‫ﻣﻲ آﻨﺪ و در ﺻﻮرﺗﻲ آﻪ هﺮ ﻳﻚ ار ﺁﻧﻬﺎ ﺗﻌﺮﻳﻒ ﻧﺸﺪﻩ ﺑﺎﺷﻨﺪ، ﺑﻪ ﺷﻤﺎ اﺧﻄﺎر ﻣﻲ دهﺪ.‬ ‫ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺎ ﻓﻌﺎل آﺮدن اﻳﻦ ﮔﺰﻳﻨﻪ در ﺳﺮﺑﺮگ ‪ Build‬از ﻗﺴﻤﺖ ‪ Project Property Pages‬در‬ ‫‪ ،VB.NET‬ﺑﻪ ﻃﻮر ﺧﻮدآﺎر در ﺗﻤﺎﻣﻲ ﻓﺮم هﺎ و ﻣﺎژول هﺎي ﺑﺮﻧﺎﻣﻪ اﻳﻦ دﺳﺘﻮر را ﻓﻌﺎل آﻨﻴﺪ.‬ ‫ﺗﻮﺟﻪ: در ﺻﻮرﺗﻲ آﻪ در ‪ ،VB.NET‬ﻧﻮع ﻣﺘﻐﻴﺮ ﺗﻌﺮﻳﻒ ﻧﺸﻮد ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض از ﻧـﻮع ‪ Object‬در‬ ‫ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد. )در 0.6.‪ VB‬از ﻧﻮع ‪ Variant‬در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﺪ(‬ ‫‪Option Strict‬‬ ‫هﻤﺎن ﻃﻮر آﻪ اﺷﺎرﻩ ﺷﺪ در ﺻﻮرﺗﻲ آﻪ ﻧﻮع ﻣﺘﻐﻴﺮي در ‪ VB.NET‬ذآﺮ ﻧﺸﻮد، ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض‬ ‫از ﻧﻮع ‪ Object‬در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد و در هﻨﮕﺎم ﻣﻘﺪاردهﻲ ﺑـﻪ ﺁن ﻣﺘﻐﻴـﺮ، ﻧـﻮع ﺁن ﺑـﻪ ﺻـﻮرت‬ ‫ﺧﻮدآﺎر ﺗﻮﺳﻂ ‪ VB‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد.‬ ‫دﺳﺘﻮرات زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫‪Dim MyVar‬‬ ‫”‪MyVar=”Hello World‬‬ ‫در دﺳﺘﻮرات ﻓﻮق اﺑﺘﺪا ﻳﻚ ﻣﺘﻐﻴـﺮ ﺑـﺪون ﻧـﻮع ﺗﻌﺮﻳـﻒ ﻣـﻲ ﺷـﻮد آـﻪ ﺑـﻪ ﻃـﻮر ﭘـﻴﺶ ﻓـﺮض از ﻧـﻮع‬ ‫‪ Object‬در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد و ﺳﭙﺲ در هﻨﮕﺎم ﻣﻘﺪاردهﻲ ﺑﻪ ﺁن، ‪ VB‬ﺑﻪ ﻃـﻮر ﺧﻮدآـﺎر ﻧـﻮع‬ ‫ﻣﻘﺪار ﻧﺴﺒﺖ دادﻩ ﺷﺪﻩ را ﺗﺸﺨﻴﺺ و ﺁن را ﺗﺒﺪﻳﻞ ﺑﻪ ﺁن ﻧﻮع ﻣـﻲ آﻨـﺪ آـﻪ در ﻣﺜـﺎل ﻓـﻮق از ﻧـﻮع‬ ‫‪ String‬در ﻧﻈﺮ ﻣﻲ ﮔﻴﺮد.‬ ‫ﭼﻨﺎﻧﭽﻪ ﻣﺎﻳﻞ هﺴﺘﻴﺪ آﻪ ﻋﻤﻞ ﺗﺒﺪﻳﻞ ﺧﻮآﺎر ﻧﻮع ﻣﺘﻐﻴﺮ ﺗﻌﺮﻳـﻒ ﻧـﺸﺪﻩ ﺗﻮﺳـﻂ ‪ VB‬اﻧﺠـﺎم ﻧـﺸﻮد و‬ ‫هﻤـﺎن ﻣﻘـﺪار ‪ Object‬در ﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﺷـﻮد، دﺳـﺘﻮر ‪ Option Strict‬را در اوﻟـﻴﻦ ﺧـﻂ آـﺪ ﻓـﺮم‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ﺑﻨﻮﻳﺴﻴﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫١٦‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)‪:(Miscellaneous‬‬ ‫ﺗﻮاﺑﻊ ﻣﺘﻔﺮﻗﻪ‬ ‫ﺗﻮاﺑﻌﻲ هﺴﺘﻨﺪ آﻪ ﻧﻤﻲ ﺗﻮان ﺁﻧﻬﺎ را در هﻴﭻ ﮔﺮوهﻲ دﺳﺘﻪ ﺑﻨﺪي آﺮد.‬ ‫اﻳﻦ ﺗﻮاﺑﻊ در اﻳﻦ ﻗﺴﻤﺖ ﻣﻮرد ﺑﺤﺚ ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ.‬ ‫)]...,2‪Choose(index,choice1 [,choice‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻣﻘﺪاري را از ﻳﻚ ﺳﺮي ﺁرﮔﻮﻣﺎن، اﻧﺘﺨﺎب و ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،index‬ﻳﻚ ﻣﻘـﺪار ﻋـﺪدي ﺑـﻴﻦ ١ ﺗـﺎ ﺗﻌـﺪاد ﺁرﮔﻮﻣـﺎن هـﺎي ‪ Choice‬اﺳـﺖ آـﻪ ﻧﻤﺎﻳـﺎﻧﮕﺮ‬ ‫ﺷﻤﺎرﻩ ﺁرﮔﻮﻣﺎﻧﻲ اﺳﺖ آﻪ ﻣﻲ ﺧﻮاهﻴﻢ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن هـﺎي 1‪ choice2 ،choice‬و…، ﻟﻴـﺴﺘﻲ از ﺁرﮔﻮﻣـﺎن هـﺎﻳﻲ هـﺴﺘﻨﺪ آـﻪ ﻣـﻲ ﺧـﻮاهﻴﻢ‬ ‫ﻣﻘﺪاري را از ﺁﻧﻬﺎ اﻧﺘﺨﺎب و ﺑﺮﮔﺸﺖ دهﻴﻢ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜـﺎل، اﮔـﺮ ﻣﻘـﺪار ‪ ١ ،index‬ﺑﺎﺷـﺪ ﻣﻘـﺪار ﺑﺮﮔـﺸﺘﻲ، ﻣﻘـﺪار ﺁرﮔﻮﻣـﺎن 1‪ choice‬و اﮔـﺮ‬ ‫‪ ٢ ،index‬ﺑﺎﺷﺪ، ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ ﺗﺎﺑﻊ، ﻣﻘﺪار ﺁرﮔﻮﻣﺎن 2‪ choice‬و ﺑﻪ هﻤﻴﻦ ﺗﺮﺗﻴﺐ ﺧﻮاهﺪ ﺑﻮد.‬ ‫ﻣﺜﻼ ﻳﻜﻲ از آﺎرﺑﺮدهﺎي اﻳﻦ ﺗﺎﺑﻊ ﺑﺮاي ﺑﺮﮔﺸﺖ ﻣﻌﺎدل ﺣﺮﻓﻲ اﻋﺪاد ﺗﻚ رﻗﻤﻲ اﺳﺖ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل، ﺗﺎﺑﻊ زﻳﺮ آﻪ )(‪ IntToString‬ﻧﺎم دارد، ﻧﺎم ﻣﻌﺎدل ﻋﺪدي آﻪ ﺑﻪ ﺁن دادﻩ ﻣﻲ ﺷـﻮد‬ ‫را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ:‬ ‫‪Function IntToString(int As Integer)As String‬‬ ‫_ , ”‪IntToString =Choose (int + 1, “zero”, “one”, “two”, “three‬‬ ‫)”‪“four”, “five”, “six”, “seven”, “eight”, “nine‬‬ ‫‪End Function‬‬ ‫دﺳﺘﻮر زﻳﺮ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ ﺑﺎﻻ، ﻣﻘﺪار ﺣﺮﻓﻲ ﻣﻌﺎدل ﻋـﺪد ٨ را ﺑﺮﮔﺮداﻧـﺪﻩ و ﺑـﺎ اﺳـﺘﻔﺎدﻩ از ﺗـﺎﺑﻊ‬ ‫)(‪ MsgBox‬ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ:‬ ‫))8(‪MsgBox(IntToString‬‬ ‫ﺗﻮﺟﻪ: در ﺻﻮرﺗﻲ آﻪ ﻣﻘﺪار ﺁرﮔﻮﻣﺎن ‪ index‬از ١ آﻤﺘﺮ ﻳﺎ ﻣﻘﺪار ﺁن از ﺗﻌﺪاد ﺁرﮔﻮﻣﺎن هـﺎي ‪choice‬‬ ‫ﺑﻴﺸﺘﺮ ﺑﺎﺷﺪ، ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﻣﻘﺪار ‪ Null‬ﺧﻮاهﺪ ﺑﻮد.‬ ‫)‪IIf(expression,truepart,falsepart‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺷﻜﻞ ﺳﺎدﻩ ﺗﺮ اﺳﺘﻔﺎدﻩ از ﺳﺎﺧﺘﺎر ﺗﺼﻤﻴﻢ ﮔﻴﺮي ‪ If Then Else‬اﺳﺖ.‬ ‫ﻣﻌﺎدل ﺳﺎﺧﺘﺎر ‪ If Then Else‬اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺖ:‬ ‫‪If expression Then‬‬ ‫‪result =truepart‬‬ ‫‪Else‬‬ ‫‪result =falsepart‬‬ ‫‪End If‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻳﻚ ﻋﺒﺎرت ﺷﺮﻃﻲ اﺳﺖ آﻪ درﺳﺖ ﻳﺎ ﻏﻠﻂ ﺑﻮدن ﺁن ﺑﺎﻳﺪ ﭼﻚ ﺷﻮد.‬ ‫اﮔ ـﺮ ﻋﺒ ـﺎرت ﺷ ـﺮﻃﻲ ﻣﻮﺟ ـﻮد در ‪ ،expression‬ﺻ ـﺤﻴﺢ ﺑﺎﺷ ـﺪ، ﻋﺒ ـﺎرت ‪ truepart‬وﮔﺮﻧ ـﻪ ﻋﺒ ـﺎرت‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫‪ falsepart‬اﺟﺮا ﺧﻮاهﺪ ﺷﺪ.‬ ‫در ﻣﺜﺎل زﻳﺮ، ﭼﻨﺎﻧﭽﻪ ﻣﻘﺪار ‪ A‬از ‪ B‬آﻮﭼﻜﺘﺮ ﺑﺎﺷﺪ، ‪ A‬در ‪ Min‬وﮔﺮﻧﻪ ‪ B‬در ‪ Min‬ﻗﺮار ﻣﻲ ﮔﻴﺮد:‬ ‫)‪Min=Iif(A < B, A, B‬‬ ‫دﺳﺘﻮر زﻳﺮ ﻣﻌﺎدل دﺳﺘﻮر ﻓﻮق اﺳﺖ:‬ ‫‪If A < B Then‬‬ ‫‪Min=A‬‬ ‫‪Else‬‬ ‫‪Min=B‬‬ ‫‪End If‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٢٦‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫)…,2‪Switch(expression1,value1,expression2,value‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻟﻴﺴﺘﻲ از ﻋﺒﺎرات ورودي را ﺑﺎ ﻳﻜﺪﻳﮕﺮ ﻣﻘﺎﻳﺴﻪ آﺮدﻩ و ﻣﻘﺪار اوﻟـﻴﻦ ﻋﺒـﺎرﺗﻲ آـﻪ ﺻـﺤﻴﺢ‬ ‫ﺑﺎﺷﺪ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ. در ﺻﻮرﺗﻲ آـﻪ هﻴﭽﻜـﺪام از ﻋﺒـﺎرات ﺻـﺤﻴﺢ ﻧﺒﺎﺷـﻨﺪ، اﻳـﻦ ﺗـﺎﺑﻊ ﻳـﻚ ﻣﻘـﺪار‬ ‫‪ Null‬را ﺑﺮﮔﺸﺖ ﺧﻮاهﺪ داد.‬ ‫ﻣﺜﺎل زﻳﺮ، ﻣﻘﺎدﻳﺮ ﻣﻮﺟـﻮد در ﻣﺘﻐﻴﺮهـﺎي ‪ X‬و ‪ Y‬را ﭼـﻚ آـﺮدﻩ و ﻣﺘﻨﺎﺳـﺐ ﺑـﺎ ﻧـﻮع ﻋﺒـﺎرات ﺷـﺮﻃﻲ‬ ‫ﺗﻌﺮﻳﻒ ﺷﺪﻩ، ﻣﻘﺪاري را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ:‬ ‫)4 ,0<‪Test =Switch(X>0 and Y>0, 1, X<0 and Y>0, 2, X<0 and Y<0, 3, X<0 and Y‬‬ ‫در دﺳﺘﻮر ﻓﻮق ﭼﻨﺎﻧﭽﻪ ‪ X‬و ‪ ،Y‬ﻣﺜﺒﺖ ﺑﺎﺷﻨﺪ ﻣﻘﺪار ١ در ﻣﺘﻐﻴﺮ ‪ Test‬ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ.‬ ‫اﮔﺮ ‪ X‬ﻣﺜﺒﺖ و ‪ Y‬ﻣﻨﻔﻲ ﺑﺎﺷﺪ، ﻣﺘﻐﻴﺮ ‪ ،Test‬ﻣﻘﺪار ٢ را ﺧﻮاهـﺪ داﺷـﺖ و ﺑﻘﻴـﻪ ﺷـﺮوط ﺑـﻪ هﻤـﻴﻦ‬ ‫ﺗﺮﺗﻴﺐ.‬ ‫ﺗﻮﺟﻪ: اﮔﺮ ‪ X‬و ‪ ،Y‬ﺻـﻔﺮ ﺑﺎﺷـﻨﺪ، هﻴﭽﻜـﺪام از ﻋﺒـﺎرات ﺻـﺤﻴﺢ ﻧﺨﻮاهﻨـﺪ ﺑـﻮد و ﻣﻘـﺪار ‪Null ،Test‬‬ ‫ﺧﻮاهﺪ ﺷﺪ.‬ ‫)‪Environ(expression‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺟﻬﺖ ﺑﺮﮔﺸﺖ ﻣﺘﻐﻴﺮهﺎي ﻣﺤﻠﻲ ﺑﻪ آﺎر ﻣﻲ رود.‬ ‫ﻣﺘﻐﻴﺮهﺎي ﻣﺤﻠﻲ، ﻣﺘﻐﻴﺮهﺎي ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ هﺴﺘﻨﺪ آـﻪ ﺑـﺎ ﻓﺮﻣـﺎن ‪ SET‬در ﺁن ﻗـﺮار دادﻩ ﺷـﺪﻩ‬ ‫اﻧﺪ.‬ ‫ﺑﺮاي دﺳﺘﺮﺳﻲ ﺑﻪ ﻣﺤﺘﻮﻳﺎت ﻳـﻚ ﻣﺘﻐﻴـﺮ ﻣﺤﻠـﻲ در ﺳﻴـﺴﺘﻢ، از ﻳـﻚ ﻋـﺪد ﻳـﺎ ﻧـﺎم ﺁن در ﺁرﮔﻮﻣـﺎن‬ ‫‪ expression‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫دﺳﺘﻮ زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫))2(‪Console.WriteLine(Environ‬‬ ‫ﺑﻪ آﻤﻚ دﺳﺘﻮر ﻓﻮق، هﻢ، ﻧﺎم ﻣﺘﻐﻴﺮ ﻣﺤﻠﻲ و هﻢ ﻣﻘﺪار ﺁن در ﺧﺮوﺟﻲ ﻧﻤﺎﻳﺶ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل:‬ ‫‪TMP=C:WINDOWS TEMP‬‬ ‫ﺑﺮاي ﺑﻪ دﺳﺖ ﺁوردن ﺗﻨﻬﺎ، ﻣﻘـﺪار ﻣﺘﻐﻴـﺮ ﻣﺤﻠـﻲ ‪ ،TMP‬ﺑﺎﻳـﺪ ﻧـﺎم ﺁن را در ﺁرﮔﻮﻣـﺎن ‪expression‬‬ ‫ذآﺮ آﻨﻴﺪ هﻤﺎﻧﻨﺪ زﻳﺮ:‬ ‫))” ‪Console.WriteLine(Environ(“TMP‬‬ ‫دﺳﺘﻮر ﻓﻮق، ﻋﺒﺎرت زﻳﺮ را ﻧﻤﺎﻳﺶ ﺧﻮاهﺪ داد:‬ ‫‪C:WINDOWS TEMP‬‬ ‫ﻣﺜﻼ دﺳﺘﻮر زﻳﺮ، ﻣﺴﻴﺮ ﭘﻮﺷﻪ وﻳﻨﺪوز ﺷﻤﺎ را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ:‬ ‫)”‪Console.WriteLine(Environ(“WinDir‬‬ ‫ﺑﺎ اﺳﺘﻔﺎدﻩ از دﺳﺘﻮر ﻓﻮق ﻧﻴـﺎزي ﺑـﻪ اﺳـﺘﻔﺎدﻩ از ﺗـﺎﺑﻊ ‪ API‬ﺑـﺮاي ﺑـﻪ دﺳـﺖ ﺁوردن ﻣـﺴﻴﺮ ﻧـﺼﺐ‬ ‫وﻳﻨﺪوز ﻧﺪارﻳﺪ.‬ ‫ﺑﺮاي ﺑﻪ دﺳﺖ ﺁوردن ﻣﻘﺎدﻳﺮ ﻣﺘﻐﻴﺮهﺎي ﻣﺤﻠﻲ ﻣﻮﺟﻮد در ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﺧﻮد، ﺑـﻪ ﺗﺮﺗﻴـﺐ از ﻋـﺪد‬ ‫١ ﺷﺮوع آﺮدﻩ و اﻳﻦ اﻋﺪاد را در ﺁرﮔﻮﻣـﺎن ‪ expression‬ﻗـﺮار دهﻴـﺪ ﺗـﺎ زﻣـﺎﻧﻲ آـﻪ اﻳـﻦ ﺗـﺎﺑﻊ، ﻳـﻚ‬ ‫ﻣﻘﺪار ﺧﺎﻟﻲ را ﺑﺮﮔﺸﺖ دهﺪ.‬ ‫ﻧﻜﺘﻪ: در ﺻﻮرﺗﻲ آﻪ ﻋﺪد ﻳﺎ ﻧﺎم ﻣﺘﻐﻴﺮ ﻣﺤﻠﻲ آﻪ ذآﺮ ﻣﻲ آﻨﻴﺪ وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ، اي ﺗـﺎﺑﻊ ﻳـﻚ‬ ‫ﻣﻘﺪار ﺧﺎﻟﻲ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٣٦‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫‪Beep‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺟﻬﺖ اﻳﺠﺎد ﻳﻚ ﺻﺪاي ﺑﻴﭗ آﻮﺗﺎﻩ ﺑﻪ آﺎر ﻣﻲ رود.‬ ‫ﻃﻮل زﻣﺎن ﭘﺨﺶ اﻳﻦ ﺻﺪاي ﺑﻴﭗ، ﻗﺎﺑﻞ ﺗﻨﻈﻴﻢ ﻧﻴﺴﺖ.‬ ‫اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ ﻧﻴﺎزي ﺑﻪ ﻧﺼﺐ ﺑﻮدن ﻳﺎ داﺷﺘﻦ آﺎرت ﺻﺪا ﻧﺪارد.‬ ‫)])(‪CallByName(object,procedurename,calltype [,arguments‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺟﻬﺖ اﺟﺮاي ﻳﻜﻲ از ﻣﺘﺪهﺎي ﻳﻚ ﺷﻲ ﻳﺎ ﺗﻌﻴﻴﻦ ﻣﻘﺪار ﺧﻮاص ﺷﻲ ﻳـﺎ ﺑﺮﮔﺮداﻧـﺪن ﻣﻘـﺪار‬ ‫ﻳﻜﻲ از ﺧﻮاص ﺷﻲ ﺑﻪ آﺎر ﻣﻲ رود.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،object‬ﻧﺎم ﺷﻲ ﻣﻮرد ﻧﻈﺮ اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،procedurename‬ﻧﺎم ﻳﻚ ﺧﻮاص ﻳﺎ ﻣﺘﺪ ﺷﻲ اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،calltype‬ﻧﻮع ﻋﻤﻠـﻲ آـﻪ ﻣـﻲ ﺧـﻮاهﻴﻢ اﻧﺠـﺎم ﺷـﻮد را ﻣـﺸﺨﺺ ﻣـﻲ آﻨـﺪ و ﻳﻜـﻲ از‬ ‫ﻣﻘﺎدﻳﺮ زﻳﺮ را ﻣﻲ ﭘﺬﻳﺮد:‬ ‫ﭘﺎراﻣﺘﺮ ‪ calltype‬در ﺗﺎﺑﻊ )(‪CallByName‬‬ ‫ﻣﻘﺎدﻳﺮ‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻣﻘﺪار‬ ‫ﻣﻘﺪار ﻳﻚ ﺧﺎﺻﻴﺖ ﺷﻲ را ﻣﻲ ﺧﻮاﻧﺪ‬ ‫‪Get‬‬ ‫ﻣﻘﺪار ﻳﻚ ﺧﺎﺻﻴﺖ ﺷﻲ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ‬ ‫‪Set‬‬ ‫ﻳﻚ ﻣﺘﺪ از ﺷﻲ را ﻓﺮاﺧﻮاﻧﻲ و اﺟﺮا ﻣﻲ آﻨﺪ‬ ‫‪Method‬‬ ‫ﺁﺧﺮﻳﻦ ﺁرﮔﻮﻣﺎن اﻳﻦ ﺗﺎﺑﻊ آﻪ ‪ arguments‬ﻧﺎم دارد، ﻳﻚ ﺁراﻳﻪ از ﻣﻘﺎدﻳﺮ اﺳﺖ.‬ ‫اﮔﺮ از ﻣﻘﺪار ‪ Set‬اﺳﺘﻔﺎدﻩ آﻨﻴﻢ، ﺑﺎﻳﺪ ﻣﻘﺪاري را آﻪ ﻣﻲ ﺧﻮاهﻴﻢ ﺑﻪ ﻳﻜﻲ از ﺧﺎﺻﻴﺖ هـﺎي ﺷـﻲ‬ ‫ﻧﺴﺒﺖ دهﻴﻢ در اﻳﻦ ﺁرﮔﻮﻣﺎن ذآﺮ آﻨﻴﻢ.‬ ‫اﮔﺮ از ﻣﻘﺪار ‪ Method‬اﺳﺘﻔﺎدﻩ ﻣﻲ آﻨﻴﻢ، ﻣﻤﻜﻦ اﺳﺖ ﻣﺘﺪ ﺗﺎﺑﻊ ﻣﺎ ﺑﺮاي اﻧﺠﺎم آﺎر ﺧـﻮد ﻧﻴـﺎز ﺑـﻪ‬ ‫ﭘﺎراﻣﺘﺮهﺎ ﻳﺎ ﻣﻘﺎدﻳﺮي داﺷﺘﻪ ﺑﺎﺷﺪ، ﭘﺲ ﺁﻧﻬﺎ را ﺑﻪ ﺗﺮﺗﻴﺐ در اﻳﻦ ﺁرﮔﻮﻣﺎن ﻳﻌﻨﻲ ‪ arguments‬ذآﺮ‬ ‫ﻣﻲ آﻨﻴﻢ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺑﻪ ﻃﻮر ﻣﻌﻤﻮل ﺑﺮاي ﺁﻧﻜﻪ ﺑﻪ ﺧﺎﺻﻴﺖ ‪ Text‬از ﺷﻲ ‪ ،TextBox‬ﻣﻘﺪاري را ﻧﺴﺒﺖ‬ ‫دهﻴﻢ، ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ:‬ ‫"‪TextBox1.Text = “Welcome To VB.NET‬‬ ‫ﺣﺎﻻ هﻤﻴﻦ آﺎر را ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ CallByName‬اﻧﺠﺎم ﻣﻲ دهﻴﻢ:‬ ‫)” ‪CallByName(TextBox1, “Text ”, CallType.Set, “Welcome to VB.NET‬‬ ‫ﺗﻮﺟﻪ: اوﻟﻴﻦ ﺁرﮔﻮﻣﺎن آﻪ ﺑﺎﻳﺪ ﻧﺎم ﺷﻲ ﻣﻮرد ﻧﻈـﺮ در ﺁن ذآـﺮ ﺷـﻮد، ﻳـﻚ ﻣﻘـﺪار رﺷـﺘﻪ اي ﻧﻴـﺴﺖ‬ ‫ﺑﻠﻜﻪ ﻧﺎم اﺻﻠﻲ ﺷﻲ را ﺑﺪون هﻴﭻ آﺎراآﺘﺮ اﺿﺎﻓﻲ ﺑﺎﻳﺪ ذآﺮ آﺮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل، دﺳﺘﻮر زﻳﺮ اﺷﺘﺒﺎﻩ اﺳﺖ و ﻳﻚ ﺧﻄﺎي زﻣﺎن اﺟﺮا اﺗﻔﺎق ﺧﻮاهﺪ اﻓﺘﺎد:‬ ‫”1‪ObjectName =“TextBox‬‬ ‫”‪CallByName ObjectName, “Text”, CallType.Set, “Welcome to VB.NET‬‬ ‫در ﺻﻮرﺗﻲ آﻪ ﻣﻲ ﺧﻮاهﻴﺪ ﻧﺎم ﺷـﻲ را در ﻳـﻚ ﻣﺘﻐﻴـﺮ ﻗـﺮار دهﻴـﺪ ﺑﺎﻳـﺪ اﺑﺘـﺪا ﺁن را از ﻧـﻮع ‪Object‬‬ ‫ﺗﻌﺮﻳﻒ آﻨﻴﺪ. ﭘﺲ دﺳﺘﻮر ﻓﻮق را ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺻﻼح ﻣﻲ آﻨﻴﻢ:‬ ‫‪Dim MyObject As Object‬‬ ‫1‪MyObject =TextBox‬‬ ‫”‪CallByName MyObject, “Text”, CallType.Set, “Welcome to VB.NET‬‬ ‫ﺑﺮاي ﺑﻪ دﺳﺖ ﺁوردن ﻣﻘﺪار ﺧﺎﺻﻴﺖ ‪ Text‬از ﺷﻲ ‪ TextBox‬ﻧﻴﺰ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ آﻨﻴﺪ:‬ ‫)‪MyText = CallByName(TextBox1, “Text”, CallType.Get‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٤٦‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
‫ﺗﺎرﻳﺨﭽﻪ وﻳﮋوال ﺑﻴﺴﻴﻚ‬ Visual Basic 1.0 ١٩٩١ ‫٠٢ ﻣﻲ‬ Visual Basic 2.0 ١٩٩٢ ‫ﻣﺎرس‬ Visual Basci 3.0 ١٩٩٣ ‫ژوﺋﻦ‬ Visual Basci 4.0 ١٩٩٦ ‫اآﺘﺒﺮ‬ Visual Basci 5.0 ١٩٩٧ ‫ﺁورﻳﻞ‬ Visual Basic 6.0 ١٩٩٨ ‫٦١ ژوﺋﻦ‬ Visual Basic .NET ٢٠٠١ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ٦٥ Visual Basic.NET ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ‬

More Related Content

PDF
Part 5
byacearmin
 
PDF
Learn Hotel Cms
byvolghan hosseyni
 
PDF
Chakra Blu
byolivencialouis1
 
PPT
Teamwork
byshekhar619
 
PPT
Ginger
byGinger Nielson
 
PDF
Mens Designs Suit
byolivencialouis1
 
DOC
Férias na BME 2008 - Estórias Renovadas
bybiblioteca.entroncamento
 
PPT
Plan De Trabajo del Proceso de Autoevauación
byMarina Fernández Miranda
 
Part 5
byacearmin
 
Learn Hotel Cms
byvolghan hosseyni
 
Chakra Blu
byolivencialouis1
 
Teamwork
byshekhar619
 
Ginger
byGinger Nielson
 
Mens Designs Suit
byolivencialouis1
 
Férias na BME 2008 - Estórias Renovadas
bybiblioteca.entroncamento
 
Plan De Trabajo del Proceso de Autoevauación
byMarina Fernández Miranda
 

Similar to vb.net

DOCX
برنامه سازی3
bymahdiehsalari
 
PDF
Jozve c#2 mohamady_zahedy
bydanesh_fd
 
PPT
c++ array learning by power point step by step
byelhamkhodayari74
 
PPT
c++ string learning by power point step by step
byelhamkhodayari74
 
PDF
Amjadi - Ebook 6 - Ref,Out - v1
byMohammad Amin Amjadi
 
PDF
برنامه سازی 2- اعظم صالح-هنرستان جنت فارسان
bytarasad
 
PDF
آموزش برنامه نویسی R و نرم افزار R Studio بخش پنجم | فرادرس
byfaradars
 
PPT
c++ power point for learning intigers and etc
byelhamkhodayari74
 
PDF
Jozve c#3 mohamady
bydanesh_fd
 
PPT
C++
byguestdcb75
 
PPT
C++
byguestdcb75
 
PPTX
آشنایی با زبان جاوا - مقدماتی اندروید
bySadegh Ghanbari Shohani
 
PDF
آموزش برنامه نویسی R و نرم افزار R Studio بخش ششم | فرادرس
byfaradars
 
PDF
طرح در س سالانه بسته های 2سمیه مبینی
bytarasad
 
PDF
طرح در س سالانه بسته های 2سمیه مبینی
bytarasad
 
DOCX
مسابقات علمی عملی هنرجویان هنرستان های شاخه فنی و حرفه ای
bytarasad
 
PDF
رایانه کار مقدماتی-فاطمه سلیمانی- منطقه کوهرنگ-هنرستان تلاش چلگرد
bytarasad
 
PDF
programming_lecture_2.pdf is very nean t
byazumarikemaru
 
PDF
Mohamady zahedy c#
bydanesh_fd
 
PPT
Java programming languages
byjavadib
 
برنامه سازی3
bymahdiehsalari
 
Jozve c#2 mohamady_zahedy
bydanesh_fd
 
c++ array learning by power point step by step
byelhamkhodayari74
 
c++ string learning by power point step by step
byelhamkhodayari74
 
Amjadi - Ebook 6 - Ref,Out - v1
byMohammad Amin Amjadi
 
برنامه سازی 2- اعظم صالح-هنرستان جنت فارسان
bytarasad
 
آموزش برنامه نویسی R و نرم افزار R Studio بخش پنجم | فرادرس
byfaradars
 
c++ power point for learning intigers and etc
byelhamkhodayari74
 
Jozve c#3 mohamady
bydanesh_fd
 
C++
byguestdcb75
 
C++
byguestdcb75
 
آشنایی با زبان جاوا - مقدماتی اندروید
bySadegh Ghanbari Shohani
 
آموزش برنامه نویسی R و نرم افزار R Studio بخش ششم | فرادرس
byfaradars
 
طرح در س سالانه بسته های 2سمیه مبینی
bytarasad
 
طرح در س سالانه بسته های 2سمیه مبینی
bytarasad
 
مسابقات علمی عملی هنرجویان هنرستان های شاخه فنی و حرفه ای
bytarasad
 
رایانه کار مقدماتی-فاطمه سلیمانی- منطقه کوهرنگ-هنرستان تلاش چلگرد
bytarasad
 
programming_lecture_2.pdf is very nean t
byazumarikemaru
 
Mohamady zahedy c#
bydanesh_fd
 
Java programming languages
byjavadib
 

vb.net

  • 1.
    ‫ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫آﺘﺎب اﻟﻜﺘﺮوﻧﻴﻜﻲ ﺁﻣﻮزﺷﻲ - آﺎرﺑﺮدي ﻓﺎرﺳﻲ ﺗﻮاﺑﻊ ‪VB.NET‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 2.
    ‫آﺘﺎب…‬ ‫درﺑﺎرﻩ‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬ ‫ﻧﺎم آﺘﺎب‬ ‫ﺑﻬﺮوز راد‬ ‫ﻧﻮﻳﺴﻨﺪﻩ‬ ‫داﻧﺸﺠﻮي آﺎﻣﭙﻴﻮﺗﺮ‬ ‫ﺗﺤﺼﻴﻼت‬ ‫زﻣﺴﺘﺎن ٢٨٣١‬ ‫ﺗﺎرﻳﺦ ﺗﺎﻟﻴﻒ‬ ‫٥٦ ﺻﻔﺤﻪ‬ ‫ﺗﻌﺪاد‬ ‫ﺻﻔﺤﺎت‬ ‫ﺗﻮﺟﻪ: اﺳﺘﻔﺎدﻩ از ﻣﻄﺎﻟﺐ اﻳﻦ آﺘﺎب ﺑﺎ ذآﺮ ﻧﺎم ﻣﺆﻟﻒ ﺑﻼﻣﺎﻧﻊ اﺳﺖ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 3.
    ‫ﻣﻘﺪﻣﻪ:‬ ‫ﺳﭙﺲ ﺧﺪاي راآﻪ در آﻨﺎر ﻧﻌﻤﺎت ﺑﻴﻜﺮان ﺧﻮد، ﺗﻮﻓﻴﻖ اراﺋﻪ اﻳﻦ آﺘﺎب ﺁﻣﻮزﺷﻲ را ﺑـﻪ دوﺳـﺘﺪاران‬ ‫زﺑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ‪ Visual Basic.NET‬ﻋﻨﺎﻳﺖ ﻓﺮﻣﻮد.‬ ‫در ﺑﺮاﺑﺮ اﻧﺒﻮﻩ آﺘﺎب هﺎي اﻟﻜﺘﺮوﻧﻴﻜﻲ ﺁﻣﻮزﺷﻲ اﻧﮕﻠﻴﺴﻲ زﺑﺎن در ﻣﻮرد زﺑﺎن هﺎي ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳـﺴﻲ،‬ ‫آﻤﺒﻮد آﺘﺎب هﺎي ﻓﺎرﺳﻲ در آﺸﻮر ﻣﺎ ﺑﻪ ﺷﺪت اﺣﺴﺎس ﻣﻲ ﺷﻮد.‬ ‫از ﺁن ﻣﻬﻢ ﺗﺮ، آﺘﺎﺑﻲ آﻪ ﺑﺮ روي ﻳﻚ ﻗﺴﻤﺖ از ﻳﻚ زﺑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺗﻤﺮآﺰ داﺷﺘﻪ و ﺑـﻪ ﻧﺤـﻮي‬ ‫ﺷﺎﻳﺴﺘﻪ و ﺑﻪ ﮔﻮﻧﻪ اي ﺳﺎدﻩ ﺑﻪ ﺗﻮﺿﻴﺢ ﻣﺒﺤﺚ ﺑﭙﺮدازد، ﺑﻪ ﻧﺪرت دﻳﺪﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫از اﻳﻦ رو ﺑﺮ ﺁن ﺷﺪم ﺗﺎ ﺑﺎ اراﺋﻪ اﻳﻦ آﺘﺎب اﻟﻜﺘﺮوﻧﻴﻜﻲ ﺁﻣﻮزﺷﻲ - آﺎرﺑﺮدي، ﻣﻬﻤﺘﺮﻳﻦ ﺗﻮاﺑﻊ ﻣﻮﺟـﻮد‬ ‫در زﺑﺎن ‪ VB.NET‬را آﻪ اآﺜﺮا ﺑﺎ زﺑﺎن 0.6.‪ VB‬ﻣﺸﺘﺮك هﺴﺘﻨﺪ، ﺑﻪ ﺻﻮرت دﺳـﺘﻪ ﺑﻨـﺪي ﺷـﺪﻩ و ﺑـﻪ‬ ‫ﻃﻮر آﺎﻣﻞ و ﺑﺎ ﺟﺰﺋﻴﺎت آﺎﻣﻞ ﺗﺮ، ﺑﺎ زﺑﺎﻧﻲ ﺳﺎدﻩ و اراﺋﻪ ﻣﺜﺎل هـﺎي ﻣﺘﻌـﺪد ﺟﻬـﺖ ﻳـﺎدﮔﻴﺮي و ﻓﻬـﻢ‬ ‫ﺑﻬﺘﺮ، ﺑﻪ دوﺳﺘﺪاران اﻳﻦ زﺑﺎن ﻗﺪرﺗﻤﻨﺪ اراﺋﻪ آﻨﻢ.‬ ‫از ﺁﻧﺠﺎ آﻪ هﻴﭻ ﻧﻮﺷﺘﻪ اي ﺑﻪ ﻃﻮر آﺎﻣﻞ ﺧﺎﻟﻲ از ﻧﻘﺺ و اﻳﺮاد ﻧﻴـﺴﺖ، ﻟـﺬا از ﺗﻤـﺎﻣﻲ ﺧﻮاﻧﻨـﺪﮔﺎن‬ ‫ﮔﺮاﻣﻲ ﺧﻮاهﺸﻤﻨﺪم اﺷﺘﺒﺎهﺎت آﺘﺎب را ﺑﻪ ﻃـﻮر ﻣـﺴﺘﻘﻴﻢ ﺑـﺎ ﺑﻨـﺪﻩ از ﻃﺮﻳـﻖ اﻳﻤﻴـﻞ زﻳـﺮ در ﻣﻴـﺎن‬ ‫ﺑﮕﺬارﻧﺪ.‬ ‫اﻣﻴﺪ اﺳﺖ آﻪ ﺑﺎ اﻳﻦ آﺎر آﻮﭼﻚ، ﮔﺎﻣﻲ در ﺟﻬﺖ اﻓﺰاﻳﺶ داﻧﺎﻳﻲ و ﺳﻄﺢ ﻋﻠﻤﻲ دوﺳـﺘﺪاران اﻳـﻦ‬ ‫زﺑﺎن ﺑﺮداﺷﺘﻪ ﺷﻮد.‬ ‫ﺑﻪ اﻣﻴﺪ ﻣﻮﻓﻘﻴﺖ روز اﻓﺰون.‬ ‫ﺑﻬﺮوز راد‬ ‫زﻣﺴﺘﺎن ٢٨٣١‬ ‫‪behrouz.rad@gmail.com‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 4.
    ‫ﻧﻜﺎت ﻣﻬﻢ:‬ ‫١( اآﺜـﺮ ﺗﻮاﺑــﻊ ‪ ،VB.NET‬ﺷــﺒﻴﻪ ﺑ ـﻪ ﺗﻮاﺑــﻊ ﻣﻮﺟــﻮد در 0.6.‪ VB‬ه ـﺴﺘﻨﺪ و ﺗﻨﻬــﺎ در ﺑﺮﺧــﻲ ﻣــﻮارد،‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ﺗﻐﻴﻴﺮاﺗﻲ در ﻧﺤﻮﻩ ي ﻓﺮاﺧﻮاﻧﻲ و اﺣﻴﺎﻧﺎ ﺳﻴﻨﺘﻜﺲ ﺗﺎﺑﻊ وﺟﻮد دارد.‬ ‫ﺑـﻪ ﻋﻨـﻮان ﻣﺜـﺎل ﺗـﺎﺑﻊ )(‪ Len‬در 0.6.‪ VB‬ﻃـﻮل ﻳـﻚ رﺷـﺘﻪ را ﺑﺮﮔـﺸﺖ ﻣـﻲ دهـﺪ اﻣـﺎ در ‪VB.NET‬‬ ‫ﺷﻤﺎ ﻗﺎدر ﺑﻪ اﻧﺠﺎم اﻳﻦ آﺎر را ﺑﺎ اﺳﺘﻔﺎدﻩ از ﻣﺘﺪ ‪ Length‬ﻣﺘﻐﻴﺮ رﺷﺘﻪ اي هﺴﺘﻴﺪ.‬ ‫ﻓﺮﺿﺎ اﮔﺮ ﻣﺘﻐﻴﺮ ‪ StrVar‬ﺑﻪ ﻋﻨﻮان ﻳﻚ ﻣﺘﻐﻴﺮ رﺷﺘﻪ اي ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﺑﺎﺷﺪ، ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴـﺪ ﻃـﻮل‬ ‫ﺁن را ﺑﺎ اﺳﺘﻔﺎدﻩ از ﻣﺘﺪ ‪ Length‬اﻳﻦ ﻣﺘﻐﻴﺮ ﺑﻪ دﺳﺖ ﺁورﻳﺪ:‬ ‫” ‪Dim strVar As String =“a short string‬‬ ‫)”‪Console.WriteLine(“The string contains“ & strVar.Length & “characters‬‬ ‫ﻳﺎ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻃﻮل اﻳﻦ ﻣﺘﻐﻴﺮ رﺷﺘﻪ اي را ﺑﺎ ﻗﺮار دادن ﺁن در ﺁرﮔﻮﻣﺎن ﺗﺎﺑﻊ )(‪ Len‬ﺑـﻪ دﺳـﺖ‬ ‫ﺁورﻳﺪ:‬ ‫”‪Dim strVar As String =“a short string‬‬ ‫)”‪Console.WriteLine(“The string contains “ & Len(strVar) & “characters‬‬ ‫٢( در ‪ VB.NET‬ﺗﻮاﺑﻌﻲ هﺴﺘﻨﺪ آﻪ آﺎر ﺗﻘﺮﻳﺒﺎ ﻳﻜﺴﺎﻧﻲ اﻧﺠﺎم ﻣﻲ دهﻨﺪ و اﻳﻦ ﻧﻜﺘﻪ ﺑـﺴﻴﺎر ﻣﻬـﻢ‬ ‫اﺳﺖ آﻪ ﺷﻤﺎ ﺑﻨﺎ ﺑﻪ ﻧﻴﺎز ﺧﻮد ﺗﺸﺨﻴﺺ دهﻴﺪ آﻪ ﺑﺎﻳﺪ از آﺪاﻣﻴﻚ از اﻳﻦ ﺗﻮاﺑﻊ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫٣( اﮔـﺮ ﺷـﻤﺎ ﻳﻜـﻲ از ﺁرﮔﻮﻣـﺎن هـﺎي اﺧﺘﻴـﺎري را ﺣـﺬف آﻨﻴـﺪ، ﺑﺎﻳـﺪ ﺑـﻪ ﺟـﺎي ﺁن از آـﺎراآﺘﺮ آﺎﻣـﺎ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫٤( ﺁرﮔﻮﻣﺎن هﺎي اﺧﺘﻴﺎري داﺧﻞ آﺮوﺷﻪ ﻗﺮار دارﻧﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺷﻜﻞ آﻠﻲ ﺗـﺎﺑﻊ )(‪ Mid‬آـﻪ ﺗﻌـﺪادي از آﺎراآﺘﺮهـﺎي ﻳـﻚ رﺷـﺘﻪ را از ﺁن اﺳـﺘﺨﺮاج‬ ‫ﻣﻲ آﻨﺪ ﺑﻪ ﺻﻮرت زﻳﺮ اﺳﺖ:‬ ‫] ‪newString =Mid(string [,start ][,length‬‬ ‫ﻣﺤــﻞ ﺷــﺮوع آﺎراآﺘﺮهــﺎﻳﻲ آــﻪ ﺑﺎﻳــﺪ اﺳــﺘﺨﺮاج ﺷــﻮﻧﺪ ﺑــﻪ وﺳــﻴﻠﻪ ﺁرﮔﻮﻣــﺎن ‪ Start‬و ﺗﻌــﺪاد‬ ‫آﺎراآﺘﺮهﺎﻳﻲ آﻪ ﺑﺎﻳﺪ اﺳﺘﺨﺮاج ﺷﻮﻧﺪ را ﺁرﮔﻮﻣﺎن ‪ length‬ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ.‬ ‫هﻤﺎﻧﮕﻮﻧﻪ آﻪ ﻣﻼﺣﻈﻪ ﻣﻲ ﺷﻮد ﺁرﮔﻮﻣﺎن ‪ start‬ﻳـﻚ ﺁرﮔﻮﻣـﺎن اﺧﺘﻴـﺎري ﺑـﻮدﻩ و ﭼﻨﺎﻧﭽـﻪ اﺳـﺘﻔﺎدﻩ‬ ‫ﻧﺸﻮد ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﻣﺤﻞ ﺷﺮوع اﺳﺘﺨﺮاج آﺎراآﺘﺮهﺎ از اﺑﺘﺪا ﻳﻌﻨـﻲ اوﻟـﻴﻦ آـﺎراآﺘﺮ رﺷـﺘﻪ در‬ ‫ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫اﮔﺮ ﺁرﮔﻮﻣﺎن ‪ length‬اﺳﺘﻔﺎدﻩ ﻧﺸﻮد، از ﻣﻜﺎن ﻣﺸﺨﺺ ﺷﺪﻩ ﺗﺎ ﺑﻪ اﻧﺘﻬﺎي رﺷـﺘﻪ اﺳـﺘﺨﺮاج ﻣـﻲ‬ ‫ﺷﻮﻧﺪ.‬ ‫ﺗﻨﻬﺎ ﺁرﮔﻮﻣﺎن اﺟﺒﺎري در اﻳﻦ ﺗﺎﺑﻊ، اوﻟﻴﻦ ﺁرﮔﻮﻣﺎن ﻳﻌﻨﻲ ‪ String‬ﻣﻲ ﺑﺎﺷﺪ آﻪ رﺷـﺘﻪ اي را ﺗﻌﻴـﻴﻦ‬ ‫ﻣﻲ آﻨﺪ آﻪ آﺎراآﺘﺮهﺎ ﺑﺎﻳﺪ از ﺁن اﺳﺘﺨﺮاج ﺷﻮﻧﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 5.
    ‫در زﻳﺮ، ﺗﻤﺎﻣﻲﺗﻮاﺑﻊ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻩ در اﻳﻦ آﺘﺎب ﺑﻪ ﺻـﻮرت دﺳـﺘﻪ ﺑﻨـﺪي ﺷـﺪﻩ ﻟﻴـﺴﺖ ﺷـﺪﻩ‬ :‫اﺳﺖ‬ .‫ﺗﻮﺟﻪ: ﺗﻮاﺑﻌﻲ آﻪ در اﻧﺘﻬﺎي ﺁﻧﻬﺎ ﭘﺮاﻧﺘﺰ وﺟﻮد ﻧﺪارد، ﺗﻮاﺑﻊ ﺑﺪون ﺁرﮔﻮﻣﺎن هﺴﺘﻨﺪ‬ :(Input/output) ‫ﺗﻮاﺑﻊ ورودي/ﺧﺮوﺟﻲ‬ InputBox(),MsgBox() :(File and Folder Manipulation) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ ﻓﺎﻳﻞ هﺎ و ﭘﻮﺷﻪ هﺎ ﺳﺮ و آﺎر دارﻧﺪ‬ ChDir(),ChDrive(),CurDir(),Dir(),FileCopy(),FileDateTime(),FileLen,GetAttr(),Kill,MkDir(),Rename(),RmDir() SetAttr() :(Data Type Identification) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺮاي ﺷﻨﺎﺳﺎﻳﻲ ﻧﻮع دادﻩ هﺎ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‬ IsArray(),IsDate(),IsDBNull(),IsNothing(),IsNumeric(),IsReference,TypeName(),VarType() :(Variable Type Conversion) ‫ﺗﻮاﺑﻊ ﺗﺒﺪﻳﻞ ﻧﻮع ﻣﺘﻐﻴﺮ‬ CBool(),CByte(),CChar(),CDate(),CDbl(),CDec(),CInt(),CLng(),CObj(),CShort(),CSng(),CStr(),CType() :(String Manipulation) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ رﺷﺘﻪ هﺎ ﺳﺮ و آﺎر دارﻧﺪ‬ Asc(),AscW(),Chr(),ChrW(),Filter(),InStr(),InStrRev(),Join(),LCase(),Left(),Len(),LTrim(),Mid(),Mid,Replace(), Right(),RTrim(),Space(),Split(),StrComp(),StrConv(),StrDup(),StrReverse(),Trim(),UCase() :(Data Formatting) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ دادﻩ هﺎ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‬ Format(),FormatCurrency(),FormatDateTime(),FormatNumber(),FormatPercent(),LSet(),RSet(),Str(),Val() :(Math) ‫ﺗﻮاﺑﻊ رﻳﺎﺿﻲ‬ Abs(),Atan(),Cos(),Exp(),Fix(),Hex(),Int(),Log(),Oct(),Pow(),Round(),Sin(),Sqrt(),Tan() :(Date and Time) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ ﺗﺎرﻳﺦ و زﻣﺎن ﺳﺮ و آﺎر دارﻧﺪ‬ DateAdd(),DateDiff(),DatePart(),DateSerial(),DateValue(),Day(), Hour(),Minute(),Month(),MonthName(),Now(),Second(), TimeSerial(),TimeValue(),Weekday(),WeekdayName(),Year() ‫( ﺑ ـﺮ روي ﻓﺎﻳ ـﻞ ه ـﺎ ﻣ ـﻮرد‬I/O) ‫ﺗ ـﻮاﺑﻌﻲ آ ـﻪ ﺟﻬ ـﺖ اﻧﺠ ـﺎم ﻋﻤﻠﻴ ـﺎت ورودي/ﺧﺮوﺟ ـﻲ‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ :(File I/O) ‫اﺳﺘﻔﺎدﻩ ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ‬ EOF(),FileAttr(),FileClose(),FileOpen(),FileGet(),FilePut(),FreeFile(), Input(),LineInput(),Loc(),Lock(),LOF(),Print(),PrintLine(),Reset(), Seek(),Unlock(),Width(),Write(),WriteLine() :(Random Numbers) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺮاي درﺳﺖ آﺮدن اﻋﺪاد ﺗﺼﺎدﻓﻲ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‬ Rnd(),Randomize :(Graphics) ‫ﺗﻮاﺑﻊ ﮔﺮاﻓﻴﻜﻲ‬ QBColor(),RGB() :(Registry) ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ رﺟﻴﺴﺘﺮي ﺳﺮ و آﺎر دارﻧﺪ‬ DeleteSetting(),GetAllSettings(),GetSetting(),SaveSetting() :(Application Collaboration) ‫ﺗﻮاﺑﻊ آﺎرﺑﺮدي‬ AppActivate(),Shell() :(Miscellaneous) ‫ﺗﻮاﺑﻊ ﻣﺘﻔﺮﻗﻪ‬ Beep,CallByName(),Choose(),Environ(),IIf(),Option,Switch() ‫در اداﻣﻪ، ﺗﻤﺎﻣﻲ ﺗﻮاﺑﻊ ذآﺮ ﺷﺪﻩ ﺑﻪ ﺗﺮﺗﻴﺐ دﺳﺘﻪ ﺑﻨـﺪي و ﺗـﻚ ﺗـﻚ، هﻤـﺮاﻩ ﺑـﺎ ﻣﺜـﺎل ﺗﻮﺿـﻴﺢ دادﻩ‬ .‫ﺧﻮاهﻨﺪ ﺷﺪ‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ٥ Visual Basic.NET ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ‬
  • 6.
    ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪآﻪ ﺗﻮاﺑﻊ ﻣﻮﺟﻮد در هﺮ دﺳﺘﻪ ﺑﻪ ﺗﺮﺗﻴﺐ ﺣﺮوف اﻟﻔﺒﺎ ﺗﻮﺿﻴﺢ دادﻩ ﻧـﺸﺪﻩ ﺑﻠﻜـﻪ‬ ‫از ﺁﺳﺎﻧﺘﺮﻳﻦ ﺷﺮوع ﺷﺪﻩ اﺳﺖ. ﺑﻨﺎﺑﺮاﻳﻦ ﻓﺮﺻﺖ اﻳـﻦ را ﺧـﻮاهﻢ داﺷـﺖ ﺗـﺎ در ﻣﺜـﺎل هـﺎﻳﻲ آـﻪ در‬ ‫ﺗﻮاﺑﻊ دﻳﮕﺮ ﺧﻮاهﻢ زد از ﺗﻮاﺑﻊ دﻳﮕﺮ ﻧﻴﺰ ﺑﺎ هﻤﺪﻳﮕﺮ اﺳﺘﻔﺎدﻩ آﻨﻢ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٦‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 7.
    ‫)‪:(Input/output‬‬ ‫ﺗﻮاﺑﻊ ورودي/ﺧﺮوﺟﻲ‬ ‫وﻳﮋوال ﺑﻴﺴﻴﻚ دو ﺗﺎﺑﻊ اﺳﺎﺳﻲ را ﺟﻬﺖ ﻧﻤﺎﻳﺶ ﻳﺎ درﺧﻮاﺳﺖ اﻃﻼﻋﺎت ﺑﻪ ﻳﺎ از آﺎرﺑﺮ ﻓﺮاهﻢ آﺮدﻩ‬ ‫اﺳﺖ.‬ ‫اﻳﻦ دو ﺗﺎﺑﻊ ﻋﺒﺎرﺗﻨﺪ از: )(‪MsgBox() , InputBox‬‬ ‫ﺑﺮﻧﺎﻣﻪ هﺎي آﺎرﺑﺮدي ﺑﺎﻳﺪ ﺑﻪ ﻧﺤﻮي ﻣﻄﻠﻮب ﺑﺎ اﺳﺘﻔﺎدﻩ از ﻓﺮم هﺎي ﺟـﺬاب و آﺎرﺑﺮﭘـﺴﻨﺪ ﺑـﺎ آـﺎرﺑﺮ‬ ‫ﺧﻮد ارﺗﺒﺎط ﺑﺮﻗﺮار آﻨﻨﺪ.‬ ‫ﻳﻜﻲ از اﻳﻦ راﻩ هﺎي ارﺗﺒﺎط، اﺳﺘﻔﺎدﻩ از اﻳﻦ دو ﺗﺎﺑﻊ آﺎﻣﻼ آﺎرﺑﺮدي ﻣﻲ ﺑﺎﺷﺪ.‬ ‫)] ‪InputBox(prompt [,title ][,default ][,xpos ][,ypos‬‬ ‫ﺗﺎﺑﻊ ‪ InputBox‬ﺟﻬﺖ ﻧﻤﺎﻳﺶ ﻳﻚ ﺟﻌﺒﻪ ﮔﻔﺘﮕﻮ )‪ (DialogBox‬هﻤﺮاﻩ ﺑﺎ ﻳـﻚ ﭘﻴﻐـﺎم و ﻳـﻚ ﺟﻌﺒـﻪ‬ ‫ﻣﺘﻦ ﺑﻪ آﺎر ﻣﻲ رود.‬ ‫اﻳﻦ آـﺎدر ﻣﺤـﺎورﻩ ﺗـﺎ زﻣـﺎن ورود اﻃﻼﻋـﺎت از ﻃـﺮف آـﺎرﺑﺮ و آﻠﻴـﻚ دآﻤـﻪ ‪ OK‬ﻳـﺎ ‪ Cancel‬ﺑـﺮ روي‬ ‫ﺻﻔﺤﻪ ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن هﺎي اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺷﺮح زﻳﺮ ﻣﻲ ﺑﺎﺷﻨﺪ:‬ ‫‪ :prompt‬ﭘﻴﻐﺎﻣﻲ آﻪ در هﻨﮕﺎم ﻇﺎهﺮ ﺷﺪن آﺎدر ﻣﺤﺎورﻩ در ﺁن ﻇﺎهﺮ ﻣﻲ ﺷﻮد.‬ ‫ﻧﻜﺘـﻪ: اﮔـﺮ ﻧﻴـﺎز دارﻳـﺪ آـﻪ ﻣـﺘﻦ ‪ Prompt‬ﺷـﻤﺎ در ﭼﻨـﺪﻳﻦ ﺧـﻂ ﭼـﺎپ ﺷـﻮد ﺁن را ﺑـﺎ اﺳـﺘﻔﺎدﻩ از‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫آﺎراآﺘﺮهﺎي ﺧﻄﻲ ‪ VbCr‬ﻳﺎ ‪ VbLf‬ﺑﻪ آﺎر ﺑﺒﺮﻳﺪ.‬ ‫‪ :Title‬ﻋﻨﻮاﻧﻲ آﻪ در ﻧﻮار ﻋﻨﻮان آﺎدر ﻣﺤﺎورﻩ ﻇﺎهﺮ ﻣﻲ ﺷﻮد.‬ ‫ﺗﻮﺟﻪ: اﮔﺮ ﺷﻤﺎ از ذآﺮ اﻳﻦ ﺁرﮔﻮﻣـﺎن اﺧﺘﻴـﺎري ﺧـﻮدداري آﻨﻴـﺪ، ﻧـﺎم ﺑﺮﻧﺎﻣـﻪ ﺷـﻤﺎ در اﻳـﻦ ﻗـﺴﻤﺖ‬ ‫ﻧﻤﺎﻳﺶ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫‪ :Default‬ﻣﻘﺪار ورودي ﭘﻴﺶ ﻓﺮض آﺎدر ﻣﺤﺎورﻩ آﻪ در ﺟﻌﺒﻪ ﻣﺘﻦ ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ.‬ ‫ﺗﻮﺻﻴﻪ: اﮔﺮ ﻗﺼﺪ ﺗﺴﺮﻳﻊ در ﺗﺼﻤﻴﻢ ﮔﻴـﺮي آـﺎرﺑﺮ در وارد آـﺮدن ﻣﻘـﺪار ورودي را دارﻳـﺪ، ﻣﻘـﺪاري را‬ ‫ﺣﺘﻤﺎ در اﻳﻦ ﻗﺴﻤﺖ ذآﺮ آﻨﻴﺪ.‬ ‫‪ :Xpos,ypos‬ﻣﺨﺘﺼﺎت ﮔﻮﺷﻪ ي ﺳﻤﺖ ﭼﭗ و ﺑﺎﻻي اﻳﻦ آﺎدر ﻣﺤـﺎورﻩ از ﺻـﻔﺤﻪ ﻧﻤـﺎﻳﺶ را ﺑـﺎ‬ ‫اﻳﻦ ﻣﻘﺎدﻳﺮ ﺗﻌﻴﻴﻦ آﻨﻴﺪ.‬ ‫ﻧﻜﺘﻪ: اﻳﻦ واﺣﺪهﺎ ﺑﺮ ﺣﺴﺐ ‪ Twips‬ﻣﻲ ﺑﺎﺷﻨﺪ.‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ هﺮ ‪ Twips‬ﺑﺮاﺑﺮ ﺑﺎ ﻳﻚ – ﭼﻬﺎرهﺰارو ﭼﻬﺎرﺻﺪو ﭼﻬـﻞ هـﺰارم اﻳـﻨﭻ و ﻳـﻚ –‬ ‫ﭘﺎﻧﺼﺪو ﺷﺼﺖ و هﻔﺖ ﺻﺪم ﺳﺎﻧﺘﻲ ﻣﺘﺮ و ﻳﻚ ﺑﻴﺴﺘﻢ ﻧﻘﻄﻪ )‪ (Point‬اﺳﺖ.‬ ‫ﺳﺎدﻩ ﺗﺮﻳﻦ ﺷﻜﻞ آﺎرﺑﺮد ﺗﺎﺑﻊ )(‪ InputBox‬ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺖ:‬ ‫)” ‪SSN =InputBox(“Please enter your name and family‬‬ ‫ﻣﺘﻨﻲ را آﻪ آﺎرﺑﺮ در اﻳﻦ آﺎدر ﻣﺤﺎورﻩ وارد ﻣﻲ آﻨﺪ در ﻣﺘﻐﻴﺮ ‪ SSN‬ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ.‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ ﺗﺎﺑﻊ هﻤﻴﺸﻪ ﻣﻘﺪاري از ﻧـﻮع ‪ String‬ﻳـﺎ رﺷـﺘﻪ اي اﺳـﺖ، ﺣﺘـﻲ اﮔـﺮ آـﺎرﺑﺮ‬ ‫ﻣﻘﺪاري ﻋﺪدي را وارد آﻨﺪ.‬ ‫ﻧﻜﺘﻪ: هﻤﻴﺸﻪ ﻣﻘﺪاري را آﻪ ﺗﻮﺳﻂ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد ﭼﻚ آﻨﻴـﺪ. ﺑـﻪ ﻋﻨـﻮان ﻣﺜـﺎل‬ ‫ﻣﻤﻜﻦ اﺳﺖ آﺎرﺑﺮ ﻣﻘﺪاري را در آﺎدر ﻣﺤﺎورﻩ وارد ﻧﻜﻨﺪ.‬ ‫در ﺻﻮرﺗﻲ آﻪ ﻓﻜﺮ ﻣﻲ آﻨﻴﺪ آﺎرﺑﺮ ﻣﻘﺪاري ﻋﺪدي را در آﺎدر ﻣﺤﺎورﻩ وارد ﻣﻲ آﻨـﺪ ﺑـﺎ اﺳـﺘﻔﺎدﻩ از‬ ‫ﺗﺎﺑﻊ )(‪ IsNumeric‬ﻣﻘﺪار ورودي را ﭼﻚ آﻨﻴﺪ ﺗﺎ ﺣﺘﻤﺎ از اﻋﺪاد ﺗﺸﻜﻴﻞ ﺷﺪﻩ ﺑﺎﺷﺪ.‬ ‫در ﺻﻮرﺗﻲ آﻪ ﻓﻜـﺮ ﻣـﻲ آﻨﻴـﺪ آـﺎرﺑﺮ ﻣﻘـﺪاري از ﻧـﻮع ﺗـﺎرﻳﺦ را وارد ﻣـﻲ آﻨـﺪ ﺑـﺎ اﺳـﺘﻔﺎدﻩ از ﺗـﺎﺑﻊ‬ ‫)(‪ IsDate‬ﻣﻘﺪار ورودي را ﭼﻚ آﻨﻴﺪ و ﺑﻪ هﻤﻴﻦ ﺗﺮﺗﻴﺐ، ﻗﺎﻟﺐ هﺎي دﻳﮕﺮ.‬ ‫ﻣﺜﺎل زﻳﺮ ﭼﻚ ﻣﻲ آﻨﺪ آﻪ ﻣﻘﺪار ورودي آﺎرﺑﺮ ﺣﺘﻤﺎ ﺗﺎرﻳﺦ ﺑﺎﺷﺪ:‬ ‫)” ‪BDay =InputBox(“Please enter your birth date‬‬ ‫‪If IsDate(BDay) Then‬‬ ‫)”‪MsgBox(“Yes. This is a valid birth date‬‬ ‫‪Else‬‬ ‫)”‪MsgBox(“Please try again with a valid birth date‬‬ ‫‪End If‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٧‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 8.
    ‫)] ‪MsgBox(prompt [,buttons][,title‬‬ ‫ﺗﺎﺑﻊ )(‪ ،MsgBox‬ﻳﻚ آﺎدر ﻣﺤﺎورﻩ را هﻤﺮاﻩ ﺑﺎ ﻳﻚ ﭘﻴﻐﺎم ﻧﻤﺎﻳﺶ دادﻩ و ﺗﺎ زﻣـﺎن ﺑـﺴﺘﻪ ﺷـﺪن آـﻪ‬ ‫ﺑﺎ آﻠﻴﻚ آﺎرﺑﺮ ﺑﺮ روي هﺮ ﻳﻚ از دآﻤﻪ هﺎي ﺁن اﻧﺠﺎم ﻣﻲ ﭘﺬﻳﺮد، ﺑﺮ روي ﺻﻔﺤﻪ ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ.‬ ‫ﭘﻴﻐـﺎﻣﻲ آـﻪ در اﻳـﻦ آـﺎدر ﻣﺤـﺎورﻩ ﻧﻤـﺎﻳﺶ دادﻩ ﺧﻮاهـﺪ ﺷـﺪ ﺑـﻪ ﻋﻨـﻮان اوﻟـﻴﻦ ﺁرﮔﻮﻣـﺎن و ﺑـﺎ ﻧـﺎم‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫‪ Prompt‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد.‬ ‫ﺳﺎدﻩ ﺗﺮﻳﻦ ﺷﻜﻞ اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺖ:‬ ‫)”!‪MsgBox(“Your Computer is running out of memory‬‬ ‫اﻳﻦ دﺳﺘﻮر ﻳﻚ ﭘﻴﻐﺎم را در ﻳﻚ آﺎدر ﻣﺤﺎورﻩ هﻤﺮاﻩ ﺑﺎ ﻳﻚ دآﻤﻪ ‪ OK‬ﻧﻤﺎﻳﺶ ﺧﻮاهﺪ داد.‬ ‫ﺗﺎﺑﻊ )(‪ MsgBox‬هﻤﭽﻨﻴﻦ ﻗﺎدر ﺑﻪ ﻧﻤﺎﻳﺶ دآﻤﻪ هﺎ و ﺁﻳﻜﻮن هﺎﻳﻲ ﻧﻴﺰ در آﺎدر ﻣﺤـﺎورﻩ ﺧـﻮد ﻣـﻲ‬ ‫ﺑﺎﺷﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻣﻘﺪاري ﻋﺪدي را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ آﻪ ﻣﻌﺮف ﻣﻘﺪار دآﻤﻪ اي اﺳـﺖ آـﻪ آـﺎرﺑﺮ ﺑـﺮ روي‬ ‫ﺁن آﻠﻴﻚ آﺮدﻩ.‬ ‫ﻣﻘﺎدﻳﺮ زﻳﺮ آﻠﻴﻪ ﻣﻘﺎدﻳﺮي هﺴﺘﻨﺪ آﻪ ﺁرﮔﻮﻣﺎن ‪ buttons‬ﻗﺎدر ﺑﻪ درﻳﺎﻓﺖ ﺁﻧﻬﺎﺳﺖ:‬ ‫ﻣﻘﺎدﻳﺮ دآﻤﻪ هﺎ در ﭘﺎراﻣﺘﺮ ‪ buttons‬از ﺗﺎﺑﻊ )(‪MsgBox‬‬ ‫ﺗﻨﻬﺎ دآﻤﻪ ‪ OK‬ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ.)ﻣﻘـﺪار ﭘـﻴﺶ‬ ‫‪ OKOnly‬ﻳﺎ 0‬ ‫ﻓﺮض(‬ ‫دآﻤﻪ هﺎي ‪ OK‬و ‪ Cancel‬ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ.‬ ‫‪ OKCancel‬ﻳﺎ 1‬ ‫دآﻤـ ـﻪ هـ ـﺎي ‪ Abort‬و ‪ Retry‬و ‪Ignore‬‬ ‫ـ‬ ‫ـ‬ ‫‪ AbortRetryIgnore‬ﻳﺎ 2‬ ‫ﻧﻤﺎﻳﺶ دادﻩ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫دآﻤــﻪ هــﺎي ‪ Yes‬و ‪ No‬و ‪ Cancel‬ﻧﻤــﺎﻳﺶ‬ ‫‪ YesNoCancel‬ﻳﺎ 3‬ ‫دادﻩ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫دآﻤﻪ هﺎي ‪ Yes‬و ‪ No‬را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫‪ YesNo‬ﻳﺎ 4‬ ‫دآﻤــﻪ هــﺎي ‪ Retry‬و ‪ Cancel‬را ﻧﻤــﺎﻳﺶ ﻣــﻲ‬ ‫‪RetryCancel‬‬ ‫دهﺪ.‬ ‫ﻣﻘﺎدﻳﺮ ﺁﻳﻜﻮن هﺎ در ﭘﺎراﻣﺘﺮ ‪ buttons‬از ﺗﺎﺑﻊ )(‪MsgBox‬‬ ‫ﭘﻴﻐﺎم ﺣﺴﺎس را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﺁﻳﻜﻮن‬ ‫‪ Critical‬ﻳﺎ 61‬ ‫ﻋﻼﻣﺖ ﺳﻮال را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﺁﻳﻜﻮن‬ ‫‪Question‬ﻳﺎ 23‬ ‫ﭘﻴﻐﺎم هﺸﺪار را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﺁﻳﻜﻮن‬ ‫‪ Exclamation‬ﻳﺎ 84‬ ‫ﭘﻴﻐﺎم اﻃﻼﻋﺎﺗﻲ را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﺁﻳﻜﻮن‬ ‫‪Information‬ﻳﺎ 46‬ ‫ﻣﻘﺎدﻳﺮ دآﻤﻪ هﺎي ﭘﻴﺶ ﻓﺮض در ﭘﺎراﻣﺘﺮ ‪ buttons‬از ﺗﺎﺑﻊ )(‪MsgBox‬‬ ‫اوﻟــﻴﻦ دآﻤــﻪ را ﺑــﻪ ﻋﻨــﻮان دآﻤــﻪ ﭘــﻴﺶ ﻓــﺮض‬ ‫1‪ DefaultButton‬ﻳﺎ 0‬ ‫اﻧﺘﺨﺎب ﻣﻲ آﻨﺪ.‬ ‫دوﻣـﻴﻦ دآﻤـﻪ را ﺑـﻪ ﻋﻨـﻮان دآﻤـﻪ ﭘـﻴﺶ ﻓـﺮض‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫2‪ DefaultButton‬ﻳﺎ 652‬ ‫اﻧﺘﺨﺎب ﻣﻲ آﻨﺪ.‬ ‫ﺳﻮﻣﻴﻦ دآﻤﻪ را ﺑـﻪ ﻋﻨـﻮان دآﻤـﻪ ﭘـﻴﺶ ﻓـﺮض‬ ‫3‪ DefaultButton‬ﻳﺎ 215‬ ‫اﻧﺘﺨﺎب ﻣﻲ آﻨﺪ.‬ ‫ﻣﻘﺎدﻳﺮ ﺷﺮﻃﻲ در ﭘﺎراﻣﺘﺮ ‪ buttons‬از ﺗﺎﺑﻊ )(‪MsgBox‬‬ ‫ﺗﺎ زﻣﺎﻧﻲ آﻪ آﺎرﺑﺮ ﺑﻪ آﺎدر ﻣﺤﺎورﻩ ﺟﻮاﺑﻲ ﻧﺪهﺪ‬ ‫‪ ApplicationModal‬ﻳﺎ 0‬ ‫ﻧﻤﻲ ﺗﻮاﻧﺪ ﺑﺮ روي هﻴﭽﻜﺪام از ﻓﺮم هﺎي ﺑﺮﻧﺎﻣﻪ‬ ‫ﺟﺎري ﺳﻮﻳﭻ آﻨﺪ.‬ ‫ﺗﺎ زﻣﺎﻧﻲ آﻪ آﺎرﺑﺮ ﺑﻪ آﺎدر ﻣﺤﺎورﻩ ﺟﻮاﺑﻲ ﻧﺪهﺪ‬ ‫‪ SystemModal‬ﻳﺎ 6904‬ ‫ﻧﻤﻲ ﺗﻮاﻧﺪ ﺑﻪ هﻴﭻ آﺪام از ﺑﺮﻧﺎﻣﻪ هﺎي در ﺣـﺎل‬ ‫اﺟﺮا ﺳﻮﻳﭻ آﻨﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٨‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 9.
    ‫ﻣﻘﺎدﻳﺮ دآﻤﻪ هﺎﺑﻪ ﺷﻤﺎ اﻳﻦ اﻣﻜﺎن را ﻣﻲ دهﺪ آﻪ ﺗﻌﻴﻴﻦ آﻨﻴﺪ آﺪاﻣﻴﻚ از دآﻤﻪ هﺎ ﺑـﺮ روي آـﺎدر‬ ‫ﻣﺤﺎورﻩ ﻇﺎهﺮ ﺷﻮد.‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﺷﻤﺎ ﻧﻤﻲ ﺗﻮاﻧﻴﺪ ﻳﻚ ﻣﻘﺪار ﻣﻨﺤﺼﺮ ﺑﻪ ﻓﺮد ﺑﺮاي اﻳﻦ ﺁرﮔﻮﻣﺎن ﺗﻌﻴﻴﻦ آﻨﻴﺪ.‬ ‫زﻣﺎﻧﻲ آﻪ روﻳﺪادي اﺳﺘﺜﻨﺎﻳﻲ ﻳﺎ ﻏﻴـﺮ ﻋـﺎدي در وﻳﻨـﺪوز رخ دهـﺪ، ﺑـﻪ وﺳـﻴﻠﻪ ﺁﻳﻜـﻮن هـﺎ ﻧـﻮع اﻳـﻦ‬ ‫روﻳﺪاد ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد. اﻳﻦ روﻳـﺪاد ﻣﻤﻜـﻦ اﺳـﺖ ﺣـﺴﺎس، ﭘﺮﺳـﺸﻲ، هـﺸﺪار و ﻳـﺎ اﻃﻼﻋـﺎﺗﻲ‬ ‫ﺑﺎﺷﺪ.‬ ‫ﻣﻘﺎدﻳﺮ ﺁﻳﻜﻮن هﺎ ﻧﻮع ﺁﻳﻜﻮن ﻇﺎهﺮ ﺷﻮﻧﺪﻩ را ﺑﺮاي ﻣﺎ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﻨﺪ.‬ ‫ﻣﻘﺎدﻳﺮ ﭘﻴﺶ ﻓﺮض دآﻤﻪ هﺎ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﻨﺪ آﻪ آﺪام دآﻤﻪ در هﻨﮕﺎم ﻇـﺎهﺮ ﺷـﺪن آـﺎدر ﻣﺤـﺎورﻩ‬ ‫ﺑﻪ ﻋﻨﻮان دآﻤﻪ ﭘﻴﺶ ﻓﺮض اﻧﺘﺨﺎب ﺷﺪﻩ ﺑﺎﺷﺪ. در ﺻﻮرﺗﻲ آﻪ ﺗﻌﻴﻴﻦ ﻧﺸﻮد اوﻟﻴﻦ دآﻤﻪ از ﺳﻤﺖ‬ ‫ﭼﭗ ﺑﻪ ﻋﻨﻮان دآﻤﻪ ﭘﻴﺶ ﻓﺮض اﻧﺘﺨﺎب ﻣﻲ ﺷﻮد.‬ ‫ﻣﻘﺎدﻳﺮ ﺷﺮﻃﻲ ﻧﻴﺰ ﻧﻮع رﻓﺘﺎر آﺎدر ﻣﺤﺎورﻩ را ﺑﻪ ﻋﻜﺲ اﻟﻌﻤﻞ آﺎرﺑﺮ ﻣﺸﺨﺺ ﻣﻲ آﻨﻨﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ ،MsgBox‬ﻣﻘﺪاري از ﻧﻮع ‪ Integer‬را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ آﻪ ﻣﻌﻴﻦ ﻣﻲ آﻨـﺪ آـﺪام دآﻤـﻪ‬ ‫ﺗﻮﺳﻂ آﺎرﺑﺮ ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ. اﻳﻦ ﻣﻘﺎدﻳﺮ در ﺟﺪول زﻳﺮ ﻟﻴﺴﺖ ﺷﺪﻩ اﺳﺖ:‬ ‫ﻣﻘﺎدﻳﺮي آﻪ ﺗﺎﺑﻊ )(‪ MsgBox‬ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‬ ‫ﺗﻮﺿﻴﺤﺎت‬ ‫ﻣﻘﺪار‬ ‫دآﻤﻪ ‪ OK‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫‪ OK‬ﻳﺎ 1‬ ‫دآﻤﻪ ‪ Cancel‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫‪ Cancel‬ﻳﺎ 2‬ ‫دآﻤﻪ ‪ Abort‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫‪ Abort‬ﻳﺎ 3‬ ‫دآﻤﻪ ‪ Retry‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫‪ Retry‬ﻳﺎ 4‬ ‫دآﻤﻪ ‪ Ignore‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫‪ Ignore‬ﻳﺎ 5‬ ‫دآﻤﻪ ‪ Yes‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫‪ Yes‬ﻳﺎ 6‬ ‫دآﻤﻪ ‪ No‬ﻓﺸﺮدﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫‪ No‬ﻳﺎ 7‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺑﺮاي ﻧﻤﺎﻳﺶ آﺎدر ﻣﺤﺎورﻩ اي ﺑﺎ دآﻤﻪ هﺎي ‪ OK‬و ‪ Cancel‬و ﺁﻳﻜﻮن ﭘﻴﻐﺎم هـﺸﺪار‬ ‫ﺑﻪ ﺻﻮرت زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ:‬ ‫_,”‪Res =MsgBox(“This operation may take several minutes‬‬ ‫)‪MsgBoxStyle.Exclamation +MsgBoxStyle.OKCancel‬‬ ‫ﻣﻘﺪاري آﻪ ﺗﻮﺳﻂ اﻳﻦ آﺎدر ﻣﺤﺎورﻩ ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﺪ ﺷﺪ، ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ ذآﺮ ﺷﺪﻩ در ﺟﺪول‬ ‫ﺑﺎﻻﺳﺖ آﻪ ﺑﺴﺘﻪ ﺑﻪ اﻧﺘﺨﺎب هﺮ ﻳﻚ از دآﻤﻪ هﺎي ‪ OK‬ﻳﺎ ‪ ،Cancel‬ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ 1 ﻳﺎ 2 ﺧﻮاهـﺪ‬ ‫ﺑﻮد.‬ ‫در ﻣﺜﺎل ﺑﻌﺪي ﻗﺼﺪ ﻇﺎهﺮ آﺮدن آﺎدر ﻣﺤﺎورﻩ اي ﺑﺎ دآﻤﻪ هﺎي ‪ Yes‬و ‪ No‬هﻤﺮاﻩ ﺑـﺎ ﺁﻳﻜـﻮن ﭘﻴﻐـﺎم‬ ‫ﺣﺴﺎس را دارﻳﻢ:‬ ‫_,”?‪Res =MsgBox(“Incomplete data.Would you like to retry‬‬ ‫)‪MsgBoxStyle.YesNo +MsgBoxStyle.Critical‬‬ ‫‪If Res =MsgBoxResult.Yes Then ‘user clicked Yes‬‬ ‫}‪{prompt again‬‬ ‫‪Else ‘user clicked No‬‬ ‫}‪{exit procedure‬‬ ‫‪Endif‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٩‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 10.
    ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎﻓﺎﻳﻞ هﺎ و ﭘﻮﺷﻪ هﺎ ﺳﺮ و آﺎر دارﻧﺪ )‪:(File and Folder Manipulation‬‬ ‫ﺗﻮاﺑﻊ زﻳﺮ ﺑﺮﺧﻲ از آﺎرهﺎي ﻣﺪﻳﺮﻳﺘﻲ را در راﺑﻄﻪ ﺑﺎ ﻓﺎﻳﻞ هﺎ و ﭘﻮﺷﻪ هﺎ هﻤﺎﻧﻨﺪ اﻧﺘﻘﺎل و ﺗﻐﻴﻴـﺮ ﻧـﺎم‬ ‫ﻓﺎﻳﻞ هﺎ، اﻳﺠﺎد ﭘﻮﺷﻪ ﺟﺪﻳﺪ، ﺣﺬف ﻓﺎﻳﻞ ﻳﺎ ﭘﻮﺷﻪ و … اﻧﺠﺎم ﻣﻲ دهﻨﺪ.‬ ‫ﻓﺮﻣﺎن هﺎي زﻳﺮ ﺑﺎ ﻣﺤﺘﻮﻳﺎت ﻓﺎﻳﻞ هﺎ آﺎري ﻧﺪاﺷﺘﻪ و اآﺜﺮا هﻤﺎﻧﻨﺪ ﻓﺮﻣﺎن هﺎي ﻣﺪﻳﺮﻳﺘﻲ ﻓﺎﻳﻞ هـﺎ و‬ ‫ﭘﻮﺷﻪ هﺎي ‪ DOS‬هﺴﺘﻨﺪ.‬ ‫)‪:GetAttr(pathname‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻣﻘﺪاري را از ﻧﻮع ‪ Integer‬ﺑﺮﮔﺸﺖ ﻣـﻲ دهـﺪ آـﻪ ﻧﻤﺎﻳـﺎﻧﮕﺮ ﺻـﻔﺖ ﻓﺎﻳـﻞ، داﻳﺮآﺘـﻮري ﻳـﺎ‬ ‫ﭘﻮﺷﻪ اي اﺳﺖ آﻪ ﻧﺎم ﺁن در ﺁرﮔﻮﻣﺎن ‪ pathname‬ﺁﻣﺪﻩ اﺳﺖ.‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ اﻳﻦ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮاﻧﺪ ﺑﺮﮔﺸﺖ دهﺪ در زﻳﺮ ﻟﻴﺴﺖ ﺷﺪﻩ اﺳﺖ:‬ ‫ﻣﻘﺎدﻳﺮي آﻪ ﺗﺎﺑﻊ )(‪ GetAttr‬ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‬ ‫ﺗﻮﺿﻴﺤﺎت‬ ‫ﻣﻘﺪار‬ ‫ﻧﺮﻣﺎل )هﻴﭻ ﺻﻔﺘﻲ ﻧﺪارد(‬ ‫‪ Normal‬ﻳﺎ 0‬ ‫ﻓﻘﻂ ﺧﻮاﻧﺪﻧﻲ‬ ‫‪ ReadOnly‬ﻳﺎ 1‬ ‫ﻣﺨﻔﻲ‬ ‫‪ Hidden‬ﻳﺎ 2‬ ‫ﺳﻴﺴﺘﻤﻲ‬ ‫‪ System‬ﻳﺎ 4‬ ‫ﺑﺮﭼﺴﺐ دراﻳﻮ‬ ‫‪ Volume‬ﻳﺎ 8‬ ‫داﻳﺮآﺘﻮري ﻳﺎ ﭘﻮﺷﻪ‬ ‫‪ Directory‬ﻳﺎ 61‬ ‫ﺁرﺷﻴﻮ )ﻓﺎﻳـﻞ در ﺁﺧـﺮﻳﻦ دﺳﺘﺮﺳـﻲ ﺗﻐﻴﻴـﺮ ﭘﻴـﺪا‬ ‫‪ Archive‬ﻳﺎ 23‬ ‫آﺮدﻩ اﺳﺖ(‬ ‫ﻧﻜﺎت ﻣﻬﻢ در اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ: ﺑﺮاي ﺗﺸﺨﻴﺺ اﻳﻨﻜـﻪ ﻋﺒـﺎرت ﻣـﺎ داراي ﭼـﻪ ﺻـﻔﺖ ﻳـﺎ ﺻـﻔﺎﺗﻲ‬ ‫اﺳﺖ از ﻋﻤﻠﮕﺮ ‪ AND‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.) ﻣﻤﻜﻦ اﺳﺖ ﻋﺒﺎرت داراي ﭼﻨﺪﻳﻦ ﺻﻔﺖ ﺑﺎﺷﺪ(‬ ‫اﮔﺮ ﻋﺒﺎرت ﻣﺎ هﻴﭽﮕﻮﻧﻪ ﺻﻔﺘﻲ ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ، ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ، ﺻﻔﺮ ﺧﻮاهﺪ ﺑﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل، ﺟﻬﺖ ﺗﺸﺨﻴﺺ اﻳﻨﻜﻪ ﻋﺒـﺎرت ﻣـﺎ داراي ﺻـﻔﺖ ﻓﻘـﻂ ﺧﻮاﻧـﺪﻧﻲ اﺳـﺖ ﻳـﺎ ﺧﻴـﺮ ﺑـﻪ‬ ‫ﺻﻮرت زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ:‬ ‫‪Result =GetAttr(FName) And FileAttribute.ReadOnly‬‬ ‫اﮔﺮ ﻋﺒﺎرت ‪ Fname‬داراي ﺻﻔﺖ ﻓﻘـﻂ ﺧﻮاﻧـﺪﻧﻲ ﺑﺎﺷـﺪ، ﻣﻘـﺪار ﺑﺮﮔـﺸﺘﻲ آـﻪ در ﻣﺘﻐﻴـﺮ ‪Result‬‬ ‫ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮد، 1 ﺧﻮاهﺪ ﺑﻮد در ﻏﻴﺮ اﻳﻨـﺼﻮرت ﺑـﺎ ﻓـﺮض اﻳﻨﻜـﻪ ﻋﺒـﺎرت ﻣـﺎ هـﻴﭻ ﺻـﻔﺖ دﻳﮕـﺮي‬ ‫ﻧﺪارد، ﻣﻘﺪار ‪ ،Result‬ﺻﻔﺮ ﺧﻮاهﺪ ﺑﻮد.‬ ‫در ﻣﺜﺎل زﻳﺮ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﻴﻢ آﻪ ﺁﻳﺎ ﻋﺒﺎرت ﻣﺎ داراي ﺻﻔﺖ ‪ Archive‬اﺳﺖ ﻳﺎ ﺧﻴﺮ:‬ ‫‪Result =GetAttr(FName)And FileAttribute.Archive‬‬ ‫اﮔﺮ ﻋﺒﺎرت، داراي ﻣﻘﺪار ‪ Archive‬ﺑﺎﺷﺪ، ﻣﻘﺪار ‪ 32 ،Result‬ﺧﻮاهﺪ ﺑﻮد.‬ ‫اﮔﺮ ﻋﺒﺎرت ﻣﺎ هﺮ دو ﻣﻘﺪار ﻓﻘﻂ ﺧﻮاﻧﺪﻧﻲ و ﺁرﺷﻴﻮ را دارا ﺑﺎﺷﺪ، ﻣﻘـﺪار ‪ ReadOnly‬و ‪Archive‬‬ ‫ﺑﺎ ﻳﻜﺪﻳﮕﺮ ﺟﻤﻊ ﻣﻲ ﺷﻮﻧﺪ، در ﻧﺘﻴﺠﻪ ‪33 ،Result‬ﺧﻮاهﺪ ﺷﺪ.‬ ‫از ﻋﻤﻠﮕﺮ ‪ OR‬ﻧﻴﺰ ﻣﻲ ﺗﻮاﻧﻴﺪ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫)‪SetAttr(pathname,attributes‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺻﻔﺘﻲ را ﺑﺮ روي ﻳﻚ ﻓﺎﻳﻞ ﻗﺮار ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،pathname‬ﻣﺴﻴﺮ ﻓﺎﻳﻠﻲ اﺳﺖ آﻪ ﻗﺮار اﺳﺖ ﺻﻔﺖ ﺑﺮ روي ﺁن اﻳﺠﺎد ﺷـﻮد و ﺁرﮔﻮﻣـﺎن‬ ‫‪ attributes‬ﻳﻚ ﻣﻘﺪار ﻋﺪدي اﺳﺖ آﻪ ﺑﺮاي ﺗﻌﻴﻴﻦ ﻧﻮع ﺻـﻔﺖ ﻳـﺎ ﺻـﻔﺖ هـﺎﻳﻲ اﺳـﺖ آـﻪ ﻗـﺮار‬ ‫اﺳﺖ ﺑﺮ روي ﻓﺎﻳﻞ اﻳﺠﺎد ﺷﻮد.‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ ﺁرﮔﻮﻣﺎن ‪ attributes‬ﻣﻲ ﺗﻮاﻧﺪ ﺑﭙﺬﻳﺮد در ﺟﺪول ﺗﺎﺑﻊ )(‪ GetAttr‬ذآﺮ ﺷﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٠١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 11.
    ‫ﻧﻜﺎت ﻣﻬﻢ دراﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ: از ﺁﻧﺠﺎ آﻪ اﻳﻦ ﺗﺎﺑﻊ ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ ﻧﺪارد، ﺁن را در ﻣﺘﻐﻴـﺮ ﻗـﺮار‬ ‫ﻧﺪهﻴﺪ.‬ ‫در اﻳﻦ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮان ﻳﻚ ﻳﺎ ﭼﻨﺪ ﺻﻔﺖ را هﻤﺰﻣﺎن اﻳﺠﺎد ﻳﺎ ﺣﺬف آﺮد.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫‪SetAttr "C:WindowsMyFile.txt", vbHidden And -vbReadOnly And vbArchive‬‬ ‫اﻳﻦ دﺳﺘﻮر ﺻﻔﺖ هﺎي ﻣﺨﻔﻲ و ﺁرﺷﻴﻮ را ﺑﺮ روي ﻓﺎﻳﻞ ‪ MyFile.txt‬اﻳﺠﺎد و ﺻﻔﺖ ﻓﻘﻂ ﺧﻮاﻧـﺪﻧﻲ‬ ‫ﺁن را ﺑﺮ ﻣﻲ دارد.‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ در ﺻﻮرﺗﻲ آﻪ ﻳﻚ ﺻﻔﺖ را ﺑﺮاي ﻳﻚ ﻓﺎﻳﻞ ﺗﻌﻴـﻴﻦ ﻣـﻲ آﻨﻴـﺪ ﺻـﻔﺖ ﻳـﺎ ﺻـﻔﺎت‬ ‫ﻗﺒﻠﻲ ﻓﺎﻳﻞ ﺣﺬف ﻣﻲ ﺷﻮﻧﺪ.‬ ‫ﺑﻪ ﻣﺜﺎل زﻳﺮ دﻗﺖ آﻨﻴﺪ:‬ ‫‪If GetAttr(file_name) And FileAttribute.Hidden Then‬‬ ‫)‪SetAttr(file_name, GetAttr(file_name)– FileAttribute..Hidden‬‬ ‫‪End If‬‬ ‫در اﻳﻦ ﻣﺜﺎل، اﺑﺘﺪا ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗـﺎﺑﻊ )(‪ GetAttr‬ﭼـﻚ ﻣـﻲ ﺷـﻮد آـﻪ ﻓﺎﻳـﻞ ﻣـﻮرد ﻧﻈـﺮ ﻣـﺎ داراي‬ ‫ﺻﻔﺖ ﻣﺨﻔﻲ اﺳﺖ ﻳﺎ ﺧﻴﺮ، اﮔﺮ داراي ﺻﻔﺖ ﻣﺨﻔﻲ ﺑﺎﺷﺪ ﺻـﻔﺖ ﻣﺨﻔـﻲ ﺁن ﺑـﺎ اﺳـﺘﻔﺎدﻩ از ﺗـﺎﺑﻊ‬ ‫)(‪ SetAttr‬ﺑﺮداﺷﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫هﻤﭽﻨﻴﻦ ﻣﻲ ﺗﻮان ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ MsgBox‬در ﻣﻮرد ﺣﺬف ﺻﻔﺖ ﻓﺎﻳﻞ ﺗﺎﻳﻴﺪ ﮔﺮﻓﺖ:‬ ‫‪If GetAttr(file_name) And FileAttribute.ReadOnly Then‬‬ ‫_ ,”?‪reply=MsgBox(“This is a read-only file.Delete it anyway‬‬ ‫)‪MsgBoxStyle.YesNo‬‬ ‫‪If reply=MsgBoxResult.Yes Then‬‬ ‫)‪SetAttr(file_name, GetAttr(file_name) - FileAttribute.ReadOnly‬‬ ‫)‪Kill(file_name‬‬ ‫‪End If‬‬ ‫‪Else‬‬ ‫)‪Kill(file_name‬‬ ‫‪End If‬‬ ‫در اﻳﻦ ﻣﺜﺎل، ﻓﺎﻳﻞ در ﻣﻮرد داﺷﺘﻦ ﺻﻔﺖ ﻓﻘﻂ ﺧﻮاﻧﺪﻧﻲ ﭼﻚ ﻣﻲ ﺷﻮد و در ﺻـﻮرت داﺷـﺘﻦ ﺁن ﺑـﺎ‬ ‫ﭘﺮﺳﺸﻲ از آﺎرﺑﺮ در ﻣﻮرد ﺣﺬف ﺁن ﺗﺎﻳﻴﺪ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫)‪Kill(pathname‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻓﺎﻳﻞ ﻳﺎ ﻓﺎﻳﻞ هﺎﻳﻲ را آﻪ ﻣﺴﻴﺮ و ﻧﺎم ﺁﻧﻬﺎ در ﺁرﮔﻮﻣﺎن ‪ pathname‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد ﭘﺎك‬ ‫ﻣﻲ آﻨﺪ.‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﻓﺎﻳﻞ هﺎي ﭘﺎك ﺷﺪﻩ ﺑﻪ ﺳﻄﻞ زﺑﺎﻟـﻪ وﻳﻨـﺪوز ﻣﻨﺘﻘـﻞ ﻧﻤـﻲ ﺷـﻮﻧﺪ و ﺑـﺮاي‬ ‫هﻤﻴﺸﻪ ﭘﺎك ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: در ﺻﻮرﺗﻲ آﻪ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ FileCopy‬ﻓﺎﻳﻠﻲ را ﺑﻪ ﺳﻄﻞ زﺑﺎﻟﻪ وﻳﻨـﺪوز اﻧﺘﻘـﺎل‬ ‫دهﻴﺪ، ﻓﺎﻳﻞ ﻣﻨﺘﻘﻞ ﺷﺪﻩ در ﭘﻨﺠﺮﻩ ﺳﻄﻞ زﺑﺎﻟﻪ ﻇﺎهﺮ ﺧﻮاهـﺪ ﺷـﺪ اﻣـﺎ ﺷـﻤﺎ ﻗـﺎدر ﺑـﻪ ﺑﺎزﻳـﺎﺑﻲ ﺁن‬ ‫ﻧﺨﻮاهﻴﺪ ﺑﻮد.‬ ‫هﻤﭽﻨﻴﻦ ﺷﻤﺎ در اﻳﻦ ﺗﺎﺑﻊ ﻗﺎدر ﺑﻪ اﺳﺘﻔﺎدﻩ از آﺎراآﺘﺮهﺎي ﺟﺎﻧﺸﻴﻨﻲ هﺴﺘﻴﺪ. )* ﻣﻌﺮف هﻤﻪ( و‬ ‫)؟ ﻣﻌﺮف ﻳﻚ آﺎراآﺘﺮ(‬ ‫اﮔﺮ ﻓﺎﻳﻠﻲ آﻪ ﻧﺎم ﺁن در ﺁرﮔﻮﻣﺎن ‪ pathname‬ذآﺮ ﻣـﻲ ﺷـﻮد وﺟـﻮد ﻧﺪاﺷـﺘﻪ ﺑﺎﺷـﺪ، ﻳـﻚ ﺧﻄـﺎي‬ ‫‪) RunTime‬زﻣﺎن اﺟﺮا ( اﺗﻔﺎق ﻣﻲ اﻓﺘﺪ.‬ ‫ﺳﻌﻲ آﻨﻴﺪ از اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ:‬ ‫‪Try‬‬ ‫)”‪Kill(“C:Log.txt‬‬ ‫‪Catch exc As Exception‬‬ ‫‪End Try‬‬ ‫در اﻳﻦ ﻣﺜﺎل ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﻌﺮﻳﻒ ﺳـﺎﺧﺘﺎر ‪ Error‬در ﺑﺮﻧﺎﻣـﻪ ﺑـﻪ وﺳـﻴﻠﻪ ‪ ،Try-Catch‬از رخ دادن‬ ‫ﺧﻄﺎي زﻣﺎن اﺟﺮا آﻪ ﻣﻤﻜﻦ اﺳﺖ ﺑﻪ دﻟﻴـﻞ وﺟـﻮد ﻧﺪاﺷـﺘﻦ ﻓﺎﻳـﻞ ‪ Log.txt‬در ﻣـﺴﻴﺮ ذآـﺮ ﺷـﺪﻩ‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫١١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 12.
    ‫اﻳﺠﺎد ﺷﻮد ﻳﺎهﺮ دﻟﻴﻞ دﻳﮕﺮي آﻪ ﻣﻤﻜﻦ اﺳﺖ از ﺣﺬف ﻓﺎﻳﻞ ﺟﻠﻮﮔﻴﺮي آﻨﺪ، ﺟﻠـﻮﮔﻴﺮي ﺷـﺪﻩ و در‬ ‫ﺻﻮرت رخ دادن ﺧﻄﺎ، آﻨﺘﺮل ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺧﻂ ﺑﻌﺪ ﻣﻨﺘﻘﻞ ﻣﻲ ﺷﻮد.‬ ‫)‪FileDateTime(pathname‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﺎرﻳﺦ و زﻣﺎن اﻳﺠﺎد ﻳﻚ ﻓﺎﻳـﻞ ﻳـﺎ ﺗـﺎرﻳﺦ و زﻣـﺎن ﺁﺧـﺮﻳﻦ زﻣـﺎﻧﻲ آـﻪ ﻓﺎﻳـﻞ ﺗﻐﻴـﺮ ﭘﻴـﺪا آـﺮدﻩ و‬ ‫وﻳﺮاﻳﺶ ﺷﺪﻩ اﺳﺖ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫))”‪Console.WriteLine(FileDateTime(“myDocument.txt‬‬ ‫ﺗﺎرﻳﺦ و زﻣﺎن ﺑﺮﮔﺸﺘﻲ ﻓﺮﺿﺎ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺧﻮاهﺪ ﺑﻮد:‬ ‫”‪“21/11/01 14:13:02 PM‬‬ ‫)‪FileLen(pathname‬‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ ﺗﺎﺑﻊ، ﻋﺪدي از ﻧـﻮع ‪ Long Integer‬ﺧﻮاهـﺪ ﺑـﻮد آـﻪ ﻣﻴـﺰان ﺣﺠـﻢ ﻓـﺎﻳﻠﻲ را‬ ‫ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ ﻧﺎم ﺁن در ﺁرﮔﻮﻣﺎن ‪ pathname‬ﺁﻣﺪﻩ اﺳﺖ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)”‪MsgBox(“The file contains” & FileLen(“.docs myDocument.txt”) & “bytes‬‬ ‫ﻣﻴﺰان ﺣﺠﻢ ﻓﺎﻳﻞ ﺗﻌﻴﻴﻦ ﺷﺪﻩ در آﺎدر ﻣﺤﺎورﻩ ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ.‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: ﺗﺎﺑﻊ )(‪ FileLen‬ﺑـﺎ ﺗـﺎﺑﻊ )(‪) LOF‬آـﻪ ﺣﺠـﻢ ﻓـﺎﻳﻠﻲ را آـﻪ هـﻢ اآﻨـﻮن ﺑـﺎز اﺳـﺖ ﺑﺮﻣـﻲ‬ ‫ﮔﺮداﻧــﺪ( ﺗﻔــﺎوت دارد. ﺟﻬــﺖ اﻃﻼﻋــﺎت ﺑﻴــﺸﺘﺮ، ﺗﻮﺿــﻴﺤﺎت ﺗــﺎﺑﻊ )(‪ LOF‬را آــﻪ در ﮔــﺮوﻩ ﺗﻮاﺑــﻊ‬ ‫ورودي/ﺧﺮوﺟﻲ ﻓﺎﻳﻞ هﺎ )‪ (File I/O‬دﺳﺘﻪ ﺑﻨﺪي ﺷﺪﻩ اﺳﺖ ﺑﺒﻴﻨﻴﺪ.‬ ‫)‪MkDir(path‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﭘﻮﺷﻪ )داﻳﺮآﺘﻮري( ﺟﺪﻳﺪ را اﻳﺠﺎد ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،path‬ﻧﺎم ﭘﻮﺷﻪ و ﻣﺴﻴﺮي اﺳﺖ آﻪ ﻗﺼﺪ اﻳﺠﺎد ﺁن را دارﻳﻢ.‬ ‫ﺑﻪ ﻣﺜﺎل زﻳﺮ ﺗﻮﺟﻪ آﻨﻴﺪ:‬ ‫)”‪MkDir(“C:Users New User‬‬ ‫اﻳﻦ دﺳﺘﻮر، ﭘﻮﺷﻪ اي ﺟﺪﻳﺪ ﺑﻪ ﻧـﺎم ‪ New Users‬در ﭘﻮﺷـﻪ ‪ Users‬اﻳﺠـﺎد ﻣـﻲ آﻨـﺪ. )اﻟﺒﺘـﻪ اﮔـﺮ‬ ‫ﭘﻮﺷﻪ ‪ Users‬وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﺪ.(‬ ‫هﻤﭽﻨﻴﻦ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﻪ ﻳﻚ ﻣﺴﻴﺮ ﻳﺎ ﭘﻮﺷﻪ دﻟﺨﻮاﻩ ﺳﻮﻳﭻ آﺮدﻩ و ﭘﻮﺷﻪ هﺎي ﺧﻮد را در ﺁﻧﺠـﺎ‬ ‫اﻳﺠﺎد آﻨﻴﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)”:‪ChDrive(“C‬‬ ‫)”:‪ChDir(“C‬‬ ‫)”‪MkDir(“Users‬‬ ‫)”‪ChDir(“Users‬‬ ‫)”‪MkDir(“New User‬‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: ﺣﺘﻤﺎ از ﺳﺎﺧﺘﺎر ‪ Try-Catch‬در ﺳﺎﺧﺖ ﭘﻮﺷﻪ هﺎ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ ﭼﻮن در ﺻـﻮرﺗﻲ آـﻪ‬ ‫ﭘﻮﺷﻪ اي آﻪ ﻗﺼﺪ اﻳﺠﺎد ﺁن را دارﻳﺪ در ﻣﺴﻴﺮ ذآﺮ ﺷﺪﻩ وﺟﻮد داﺷﺘﻪ ﺑﺎﺷـﺪ، ﺧﻄـﺎﻳﻲ رخ ﺧﻮاهـﺪ‬ ‫داد. )اﻟﺒﺘﻪ اﮔﺮ ﭘﻮﺷﻪ وﺟﻮد داﺷﺖ، ﻣﻲ ﺗﻮاﻧﻴﺪ ﺁن را ﺣﺬف و اﻗﺪام ﺑﻪ اﻳﺠﺎد ﭘﻮﺷﻪ ي ﺟﺪﻳﺪ آﻨﻴﺪ(‬ ‫)‪RmDir(path‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺑﺮاي ﺣﺬف ﭘﻮﺷﻪ ﻳﺎ داﻳﺮآﺘﻮري آﻪ ﻣﺴﻴﺮ و ﻧﺎم ﺁن در ﺁرﮔﻮﻣﺎن ‪ Path‬ﺁﻣـﺪﻩ اﺳـﺖ ﺑـﻪ آـﺎر‬ ‫ﻣﻲ رود.‬ ‫ﻧﻜﺎت ﻣﻬﻢ در اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ: ﺁرﮔﻮﻣﺎن ‪ Path‬ﻧﻤﻲ ﺗﻮاﻧـﺪ داراي آﺎراآﺘﺮهـﺎي ﺟﺎﻧـﺸﻴﻨﻲ )* و‬ ‫؟( ﺑﺎﺷﺪ. ﺑﻪ ﻋﺒﺎرت دﻳﮕﺮ ﺷﻤﺎ ﻧﻤﻲ ﺗﻮاﻧﻴﺪ ﭼﻨﺪﻳﻦ ﭘﻮﺷﻪ را ﺑـﺎ ﻳـﻚ ﺑـﺎر ﻓﺮاﺧـﻮاﻧﻲ اﻳـﻦ ﺗـﺎﺑﻊ ﺣـﺬف‬ ‫آﻨﻴﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٢١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 13.
    ‫ﺑﺮاي ﺣﺬف ﭘﻮﺷﻪ،ﺑﺎﻳﺪ دو ﺷﺮط زﻳﺮ ﺑﺮﻗﺮار ﺑﺎﺷﺪ:‬ ‫١( ﭘﻮﺷﻪ ﺧﺎﻟﻲ ﺑﺎﺷﺪ. ٢( ﭘﻮﺷﻪ ﺟﺎري ﻧﺒﺎﺷﺪ.‬ ‫در ﺻﻮرت رﻋﺎﻳﺖ ﻧﻜﺮدن هﺮ ﻳﻚ از ﻣﻮارد ﻓﻮق، ﻳﻚ ﺧﻄﺎي زﻣﺎن اﺟﺮا اﺗﻔﺎق ﻣﻲ اﻓﺘﺪ.‬ ‫ﺑﺮاي ﺣﺬف ﭘﻮﺷﻪ اي آﻪ داراي ﺗﻌﺪادي ﻓﺎﻳـﻞ اﺳـﺖ، اﺑﺘـﺪا ﺑـﺎ ﺗـﺎﺑﻊ )(‪ Kill‬ﻓﺎﻳـﻞ هـﺎي درون ﺁن را‬ ‫ﺣﺬف و ﺳﭙﺲ ﺗﺎﺑﻊ ‪ RmDir‬را ﻓﺮاﺧﻮاﻧﻲ آﻨﻴـﺪ. ﻋـﻼوﻩ ﺑـﺮ ﺁن اﮔـﺮ ﭘﻮﺷـﻪ ي ﺷـﻤﺎ داراي ﺗﻌـﺪادي‬ ‫زﻳﺮﭘﻮﺷﻪ ﻧﻴﺰ ﺑﺎﺷﺪ، ﺑﺎﻳﺪ ﺁﻧﻬﺎ را هﻢ ﻗﺒﻞ از ﺣﺬف ﭘﻮﺷﻪ ي اﺻﻠﻲ ﺣﺬف آﻨﻴﺪ.‬ ‫ﻓﺮﻣﺎن زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)”‪RmDir(“C:Users‬‬ ‫در ﺻﻮرﺗﻲ آﻪ ﭘﻮﺷﻪ ي ‪ Users‬داراي زﻳﺮﭘﻮﺷـﻪ اي ﺑـﻪ ﻧـﺎم ‪ New User‬ﺑﺎﺷـﺪ، ﺧﻄـﺎﻳﻲ اﺗﻔـﺎق‬ ‫ﻣﻲ اﻓﺘﺪ.‬ ‫ﭘﺲ ﻓﺮﻣﺎن ﻓﻮق را ﺑﻪ ﺻﻮرت زﻳﺮ اﺻﻼح ﻣﻲ آﻨﻴﻢ:‬ ‫)”‪RmDir(“C:Users New User‬‬ ‫)”‪RmDir(“C:Users‬‬ ‫)‪ChDir(path‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﭘﻮﺷﻪ )داﻳﺮآﺘﻮري( ﺟﺎري را ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺑﺮاي ﺳﻮﻳﭻ ﺑﻪ ﭘﻮﺷﻪ ‪ C:Windows‬ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ:‬ ‫)”‪ChDir(“C:Windows‬‬ ‫ﻧﻜﺎت ﻣﻬﻢ: اﮔﺮ در ﺁرﮔﻮﻣﺎن ‪ path‬اﻳﻦ ﺗـﺎﺑﻊ از ﺁوردن ﻧـﺎم دراﻳـﻮ ﺧـﻮدداري ﺷـﻮد، ﺗـﺎﺑﻊ )(‪ChDir‬‬ ‫ﺗﻼش ﻣﻲ آﻨﺪ ﺗﺎ در دراﻳﻮ ﺟﺎري ﺑﻪ ﭘﻮﺷﻪ اي آـﻪ ﻧـﺎم ﺁن در در ﺁرﮔﻮﻣـﺎن ‪ path‬ﻣـﺸﺨﺺ ﺷـﺪﻩ‬ ‫ﺳﻮﻳﭻ آﻨﺪ و اﮔﺮ ﭘﻮﺷﻪ وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ، ﻳﻚ ﺧﻄﺎ رخ ﻣﻲ دهﺪ و ﻣﺴﻴﺮ ﺟﺎري ﺗﻐﻴﻴﺮ ﭘﻴﺪا ﻧﻤﻲ‬ ‫آﻨﺪ.‬ ‫ﺗﻮﺟﻪ: ﺗﺎﺑﻊ )(‪ ،ChDir‬ﭘﻮﺷﻪ ﺟﺎري را ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ ﻧﻪ دراﻳﻮ ﺟﺎري را.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔﺮ دراﻳﻮ ﺟﺎري ):‪ (C‬ﺑﺎﺷﺪ، دﺳﺘﻮر زﻳﺮ ﭘﻮﺷﻪ ﺟﺎري را ﺑـﻪ ﭘﻮﺷـﻪ دﻳﮕـﺮي در دراﻳـﻮ‬ ‫):‪ (D‬ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ اﻣﺎ دراﻳﻮ ):‪ (C‬ﺑﻪ ﻋﻨﻮان دراﻳﻮ ﺟﺎري ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ:‬ ‫”‪ChDir “D:TMP‬‬ ‫ﺑﺮاي ﺗﻐﻴﻴﺮ دراﻳﻮ ﺟﺎري از ﺗـﺎﺑﻊ )(‪ ChDrive‬آـﻪ ﺑـﻪ ﻋﻨـﻮان ﺗـﺎﺑﻊ ﺑﻌـﺪي ﺗﻮﺿـﻴﺢ دادﻩ ﺷـﺪﻩ اﺳـﺖ‬ ‫اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﺷﻤﺎ هﻤﭽﻨﻴﻦ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻧﺎم هﺎي ﻧﺴﺒﻲ را ﺑﻪ ﻋﻨﻮان ﻧﺎم ﭘﻮﺷﻪ ﺑﻪ آﺎر ﺑﺒﺮﻳﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل دﺳﺘﻮر )”..“(‪ ChDir‬ﭘﻮﺷﻪ ﺟﺎري را ﻳﻚ ﻣﺮﺣﻠﻪ ﺑﻪ ﺑﺎﻻ در ﭘﻮﺷﻪ اﺻﻠﻲ اﻧﺘﻘﺎل ﻣﻲ‬ ‫ده ـﺪ در ﺻ ـﻮرﺗﻲ آ ـﻪ دﺳ ـﺘﻮر )”‪ ،ChDir(“..MyFiles‬ﭘﻮﺷ ـﻪ ‪ MyFiles‬را در ﭘﻮﺷ ـﻪ اﺻ ـﻠﻲ ﺑ ـﻪ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ﻋﻨﻮان ﭘﻮﺷﻪ ﺟﺎري در ﻧﻈﺮ ﻣﻲ ﮔﻴﺮد.‬ ‫ﺗﻮﺟﻪ: هﻢ ﭘﻮﺷﻪ ي ﺟﺎري و هﻢ ﭘﻮﺷﻪ ي ‪ ،MyFiles‬دو زﻳﺮﭘﻮﺷﻪ در ﻳﻚ ﭘﻮﺷﻪ اﺻﻠﻲ هﺴﺘﻨﺪ.‬ ‫)‪ChDrive(drive‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ دراﻳﻮ ﺟﺎري را ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ. هﻤﺎﻧﻨﺪ: )”:‪ChDrive(“D‬‬ ‫اﻳﻦ دﺳﺘﻮر، دراﻳﻮ ﺟﺎري را ﺑﻪ دراﻳﻮ ‪ D‬ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ.‬ ‫ﻧﻜﺎت ﻣﻬﻢ: دراﻳﻮي آﻪ ﻧﺎم ﺁن در ﺁرﮔﻮﻣﺎن ‪ drive‬ذآﺮ ﻣﻲ ﺷﻮد ﺑﺎﻳﺪ وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﺪ.‬ ‫اﮔﺮ در ﺁرﮔﻮﻣﺎن ‪ drive‬ﻧﺎم ﭼﻨﺪﻳﻦ دراﻳﻮ ذآﺮ ﺷﻮد، ﻧﺎم اوﻟﻴﻦ دراﻳﻮ ﺟﻬﺖ ﺗﻐﻴﻴﺮ در ﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﻣـﻲ‬ ‫ﺷﻮد.‬ ‫)] ‪CurDir([drive‬‬ ‫هﻨﮕﺎﻣﻲ آﻪ اﻳﻦ ﺗﺎﺑﻊ، ﺑﺪون ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ drive‬ﻓﺮاﺧﻮاﻧﻲ ﺷﻮد، ﻧﺎم ﭘﻮﺷﻪ ﺟﺎري را در دراﻳـﻮ‬ ‫ﺟﺎري ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺑﺮاي اﻳﻨﻜﻪ ﺑﻔﻬﻤﻴﺪ آﻪ آﺪام ﭘﻮﺷﻪ در دراﻳﻮ دﻳﮕﺮي ﭘﻮﺷﻪ ﺟـﺎري اﺳـﺖ، ﻧـﺎم دراﻳـﻮ را در ﺁرﮔﻮﻣـﺎن‬ ‫‪ drive‬ذآﺮ آﻨﻴﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٣١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 14.
    ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎلاﮔﺮ ﺷﻤﺎ در ﻳـﻚ ﭘﻮﺷـﻪ در دراﻳـﻮ ):‪ (C‬ﺑﺎﺷـﻴﺪ، دﺳـﺘﻮر )(‪ CDir =CurDir‬ﻣـﺴﻴﺮ‬ ‫ﭘﻮﺷﻪ ﺟﺎري را در دراﻳﻮ ﺟﺎري ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺑﺮاي اﻳﻨﻜﻪ ﺑﻔﻬﻤﻴﻢ آﻪ ﭘﻮﺷﻪ ﺟﺎري در ﻳﻚ دراﻳﻮ دﻳﮕﺮ ﻣـﺜﻼ ):‪ (D‬ﭼﻴـﺴﺖ، ﺗـﺎﺑﻊ )(‪ CurDir‬را ﺑـﻪ‬ ‫ﺻﻮرت زﻳﺮ ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ آﻨﻴﻢ:‬ ‫)”‪DDir =CurDir(“D‬‬ ‫)]] ‪Dir([pathname [,attributes‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، دو ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري را درﻳﺎﻓـﺖ آـﺮدﻩ و ﻳـﻚ ﻣﻘـﺪار از ﻧـﻮع رﺷـﺘﻪ اي را آـﻪ ﻧـﺎم ﻓﺎﻳـﻞ ﻳـﺎ‬ ‫ﭘﻮﺷﻪ اي اﺳﺖ آﻪ ﺑﺎ ﺁرﮔﻮﻣﺎن ‪) pathname‬ﻣـﺴﻴﺮ ﻓﺎﻳـﻞ ﻳـﺎ ﭘﻮﺷـﻪ( ﻳـﺎ ‪) attributes‬ﺻـﻔﺖ ﻳـﺎ‬ ‫ﺻﻔﺎت ﻓﺎﻳﻞ( ﻣﻄﺎﺑﻘﺖ دارد، ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﻧﻜﺎت ﻣﻬﻢ در اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ:‬ ‫در اﻳﻦ ﺗﺎﺑﻊ ﻣﺠﺎز ﺑﻪ اﺳﺘﻔﺎدﻩ از ﻋﻼﻣﺖ هﺎي ﺟﺎﻳﮕﺰﻳﻦ هﺴﺘﻴﺪ.)* و ؟(‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫‪Dim sFile As String‬‬ ‫)"‪sFile = Dir("C:Windows‬‬ ‫‪Do Until sFile = vbNullString‬‬ ‫‪Console.WriteLn sFile‬‬ ‫)(‪sFile = Dir‬‬ ‫‪Loop‬‬ ‫در اﻳﻦ ﻣﺜﺎل، آﻠﻴﻪ ﻓﺎﻳﻞ هﺎﻳﻲ آﻪ در ﭘﻮﺷﻪ ‪ Windows‬وﺟﻮد دارﻧﺪ)در ﭘﻮﺷـﻪ اﺻـﻠﻲ ‪Windows‬‬ ‫ﻧﻪ در زﻳﺮ ﭘﻮﺷﻪ هﺎي ﺁن( ﭼﺎپ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫اﮔﺮ هﻴﭻ ﻓﺎﻳﻠﻲ ﺑﺎ ﺁرﮔﻮﻣﺎن هﺎي ذآﺮ ﺷﺪﻩ در ﺗﺎﺑﻊ )(‪ Dir‬ﺻﺪق ﻧﻜﻨﺪ، ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ، ﻳـﻚ ﻣﻘـﺪار‬ ‫ﺧﺎﻟﻲ ﺧﻮاهﺪ ﺑﻮد.‬ ‫دوﻣﻴﻦ ﺁرﮔﻮﻣﺎن، ﻳﻚ ﻣﻘﺪار ﻋﺪدي ﻳﺎ ﺛﺎﺑﺖ اﺳـﺖ آـﻪ در ﺗﻮﺿـﻴﺤﺎت ﺗـﺎﺑﻊ )(‪ SetAttr‬ﺁﻣﺪﻧـﺪ و ﻣـﻲ‬ ‫ﺗﻮاﻧﺪ ﻳﻚ ﻣﻘﺪار ﻳﺎ ﺑﻴﺸﺘﺮ ﺑﺎﺷﺪ.‬ ‫در ﺻﻮرﺗﻲ آﻪ از ذآﺮ اﻳﻦ ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ﺧﻮدداري ﺷﻮد، ﺗﻨﻬﺎ ﻓﺎﻳﻞ هﺎي ‪) Normal‬ﻓﺎﻳـﻞ هـﺎي‬ ‫ﺑﺪون ﺻﻔﺖ( ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫ﻳﻜﻲ از آﺎرﺑﺮدهﺎي اﻳﻦ ﺗﺎﺑﻊ ﺑﺮاي ﺗﻌﻴﻴﻦ وﺟﻮد ﻳﻚ ﻓﺎﻳﻞ ﻳﺎ ﭘﻮﺷﻪ در ﻣﺴﻴﺮ ﻣﺸﺨﺺ ﺷﺪﻩ اﺳﺖ.‬ ‫ﺑﻪ ﻓﺮﻣﺎن زﻳﺮ ﺗﻮﺟﻪ آﻨﻴﺪ:‬ ‫)”‪OCXFile =Dir(“C:WINDOWS SYSTEM MSCOMCTL.OCX‬‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ ﻓﺮﻣﺎن در ﺻﻮرت وﺟﻮد ﻓﺎﻳﻞ ‪ MSCOMCTL.OCX‬در ﻣﺴﻴﺮ ذآﺮ ﺷﺪﻩ، هﻤﺎن‬ ‫ﻧﺎم ﻓﺎﻳﻞ اﺳﺖ در ﻏﻴﺮ اﻳﻨﺼﻮرت ﻳﻚ ﻣﻘﺪار ﺗﻬﻲ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫در اﻳﻦ ﻣﺜﺎل ﻣﻲ ﺧﻮاهﻴﻢ ﺑﺪاﻧﻴﻢ آﻪ ﭼﻨﺪ ﻓﺎﻳﻞ ﺑﺎ ﭘﺴﻮﻧﺪ ‪ DLL‬در ﻣﺴﻴﺮي آﻪ ﻣﺸﺨﺺ ﻣﻲ آﻨـﻴﻢ‬ ‫وﺟﻮد دارد:‬ ‫‪Dim DLLFile As String‬‬ ‫‪Dim DLLFiles As Integer‬‬ ‫)”‪DLLFile =Dir(“C:WINNT SYSTEM *.DLL‬‬ ‫1+ ‪If DLLFile <>“” Then DLLFiles =DLLFiles‬‬ ‫”“>< ‪While DLLFile‬‬ ‫)(‪DLLFile =Dir‬‬ ‫1+ ‪DLLFiles =DLLFiles‬‬ ‫‪End While‬‬ ‫)‪MsgBox(DLLFiles‬‬ ‫در اﻳﻦ دﺳﺘﻮرات، ﺗﺎﺑﻊ )(‪ Dir‬اﺑﺘﺪا ﺑﺎ ﻳﻜﻲ از ﺁرﮔﻮﻣﺎن هﺎﻳﺶ ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ ﺷﻮد.‬ ‫اﮔﺮ ﻳﻚ ﻓﺎﻳﻞ ‪ DLL‬در ﻣﺴﻴﺮ ﻣﺸﺨﺺ ﺷﺪﻩ وﺟﻮد داﺷﺖ، ﻧﺎم ﺁن ﺑﺮﮔـﺸﺖ دادﻩ ﻣـﻲ ﺷـﻮد و ﺗـﺎﺑﻊ‬ ‫ﻣﺠﺪدا ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ ﺷﻮد اﻣﺎ اﻳﻦ ﺑﺎر ﺑﺪون ﺁرﮔﻮﻣﺎن.‬ ‫هﺮ ﺑﺎر آﻪ ﺗﺎﺑﻊ، ﻧﺎم ﻳﻚ ﻓﺎﻳﻞ ‪ DLL‬را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ ﻳﻚ واﺣﺪ ﺑﻪ ﻣﺘﻐﻴﺮ ‪ DLLFiles‬اﺿـﺎﻓﻪ ﻣـﻲ‬ ‫ﺷﻮد. اﻳﻦ آﺎر ﺑﺮاي ﺗﻤﺎﻣﻲ ﻓﺎﻳﻞ هﺎي ‪ DLL‬در ﻣﺴﻴﺮ ﻣـﺸﺨﺺ ﺷـﺪﻩ اداﻣـﻪ ﻣـﻲ ﻳﺎﺑـﺪ و در ﺁﺧـﺮ،‬ ‫ﻣﻘﺪار ﻣﺘﻐﻴﺮ ‪ ،DLLFiles‬ﺗﻌﺪاد ﻓﺎﻳﻞ هﺎي ﻣﺸﺨﺺ ﺷﺪﻩ در ﻣﺴﻴﺮ ﺗﻌﻴﻴﻦ ﺷﺪﻩ را دارا ﻣﻲ ﺑﺎﺷﺪ.‬ ‫ﺧﻮب ﻣﻲ ﺧﻮاهﻴﻢ ﺗﺎﺑﻊ را ﮔﺴﺘﺮش دهﻴﻢ و ﻓﻘﻂ ﻓﺎﻳﻞ هﺎي ‪ DLL‬اي را ﺟـﺴﺘﺠﻮ آﻨـﻴﻢ آـﻪ داراي‬ ‫ﺻﻔﺖ ‪) Hidden‬ﻣﺨﻔﻲ( هﺴﺘﻨﺪ.‬ ‫ﭘﺲ ﺗﺎﺑﻊ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻣﻲ ﺷﻮد:‬ ‫)‪DLLFile =Dir(“C:WINNT SYSTEM *.DLL”,FileAttribute.Hidden‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٤١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 15.
    ‫ﺷﻤﺎ هﻤﭽﻨﻴﻦ ﻗﺎدرﺑﻪ ﺗﺮآﻴﺐ ﭼﻨﺪﻳﻦ ﺻﻔﺖ ﺑﺎ هﻢ هـﺴﺘﻴﺪ. ﻣـﺜﻼ ﻓﺎﻳـﻞ هـﺎي ‪ DLL‬اي آـﻪ داراي‬ ‫ﺻﻔﺎت ﻣﺨﻔﻲ و ﻓﻘﻂ ﺧﻮاﻧﺪﻧﻲ و ﺳﻴﺴﺘﻤﻲ هﺴﺘﻨﺪ.‬ ‫ﺑــــﺮاي ﺗﻌﻴــــﻴﻦ ﻧــــﺎم زﻳﺮﭘﻮﺷــــﻪ هــــﺎﻳﻲ آــــﻪ در ﻳــــﻚ ﭘﻮﺷــــﻪ ﻗــــﺮار دارﻧــــﺪ ﺑﺎﻳــــﺪ از ﺻــــﻔﺖ‬ ‫‪ FileAttribute.Directory‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ آﻪ ﻧﺎم ﭘﻮﺷﻪ اﻳﻲ را ﺑﺮ ﮔﺸﺖ ﻣﻲ دهﺪ آﻪ ﻧﺮﻣـﺎل ﻳـﺎ‬ ‫اﺻﻄﻼﺣﺎ ﺑﺪون ﺻﻔﺖ ﺑﺎﺷﺪ. )در 0.6.‪ VB‬ﺑﺎ ﻧﺎم ‪ vbDirectory‬ﺷﻨﺎﺧﺘﻪ ﻣﻲ ﺷﻮد(‬ ‫ﺑﺮاي ﺗﻌﻴﻴﻦ اﻳﻨﻜﻪ ﻣﻘﺪار ورودي، ﻓﺎﻳﻞ اﺳﺖ ﻳﺎ ﭘﻮﺷﻪ ﺑﺎﻳـﺪ ﺧـﻮاص ﻣﻘـﺪار ورودي را ﺑـﺎ اﺳـﺘﻔﺎدﻩ از‬ ‫ﺗﺎﺑﻊ )(‪ GetAttr‬ﺑﺮرﺳﻲ آﻨﻴﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ ﺗﻌﺪاد زﻳﺮﭘﻮﺷﻪ هﺎي ﻣﻮﺟﻮد در ﭘﻮﺷﻪ ‪ System‬را ﺑﻪ دﺳﺖ ﻣﻲ ﺁورد:‬ ‫‪Dim path,FName As String‬‬ ‫‪Dim totFolders As Integer‬‬ ‫”‪path =“C:WindowsSystem‬‬ ‫)‪FName =Dir(path,FileAttribute.Directory‬‬ ‫”“>< ‪While FName‬‬ ‫_=)‪If (GetAttr(path &FName)And FileAttribute.Directory‬‬ ‫‪FileAttribute.Directory Then‬‬ ‫)‪Console.WriteLine(FName‬‬ ‫1 + ‪totFolders =totFolders‬‬ ‫‪End If‬‬ ‫)(‪FName =Dir‬‬ ‫‪End While‬‬ ‫)”‪Console.WriteLine(“Found“ & totFolders & “folders‬‬ ‫)‪FileCopy(source_file,dest_file‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻓﺎﻳﻞ را ﺑﻪ ﻳﻚ ﻣﻜﺎن ﺟﺪﻳﺪ ﺑﺮ روي هﺎرددﻳﺴﻚ آﭙﻲ ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،source_file‬ﻧﺎم ﻓﺎﻳﻠﻲ اﺳﺖ آﻪ ﻗﺮار اﺳﺖ آﭙﻲ ﺷﻮد.‬ ‫اﮔﺮ ﻓﺎﻳﻞ در ﭘﻮﺷﻪ ﺟﺎري ﺑﺎﺷﺪ ﻓﻘﻂ ذآﺮ ﻧﺎم ﻓﺎﻳﻞ آﻔﺎﻳـﺖ ﻣـﻲ آﻨـﺪ در ﻏﻴـﺮ اﻳﻨـﺼﻮرت ﺑﺎﻳـﺪ ﻣـﺴﻴﺮ‬ ‫آﺎﻣﻞ ﻓﺎﻳﻞ را ذآﺮ آﻨﻴﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ dest_file‬ﻧﺎم ﻓﺎﻳﻞ و ﻣﺴﻴﺮي اﺳﺖ آﻪ ﻓﺎﻳﻞ ﻗﺮار اﺳﺖ ﺑﻪ ﺁﻧﺠﺎ آﭙﻲ ﺷﻮد.‬ ‫ﺳﻪ ﻧﻜﺘﻪ ﻣﻬﻢ در راﺑﻄﻪ ﺑﺎ اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ:‬ ‫١( ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺮاي ﻓﺎﻳﻠﻲ آﻪ ﻗﺮار اﺳﺖ ﺑﻪ ﻣﻜﺎن دﻳﮕﺮي آﭙﻲ ﺷﻮد ﻧﺎم ﺟﺪﻳﺪي در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ.‬ ‫٢( در ﺻﻮرﺗﻲ آﻪ در ﻣﻮﻗﻊ آﭙﻲ ﻓﺎﻳﻞ، ﺑﺮﻧﺎﻣﻪ ي دﻳﮕﺮي در ﺣـﺎل اﺳـﺘﻔﺎدﻩ از ﻓﺎﻳـﻞ ﺑﺎﺷـﺪ، ﻓﺎﻳـﻞ‬ ‫آﭙﻲ ﻧﺨﻮاهﺪ ﺷﺪ.‬ ‫٣( در اﻳﻦ ﺗﺎﺑﻊ ﻣﺠﺎز ﺑﻪ اﺳﺘﻔﺎدﻩ از آﺎراآﺘﺮهﺎي ﺟﺎﻳﮕﺰﻳﻦ ﻧﻴﺴﺘﻴﺪ.)* و ؟( ﺑـﻪ ﻋﺒـﺎرت دﻳﮕـﺮ ﻧﻤـﻲ‬ ‫ﺗﻮاﻧﻴﺪ ﺗﻨﻬﺎ ﺑﺎ ﻳﻚ ﺑﺎر ﻓﺮاﺧﻮاﻧﻲ اﻳﻦ ﺗﺎﺑﻊ، ﭼﻨﺪﻳﻦ ﻓﺎﻳﻞ را هﻤﺰﻣﺎن آﭙﻲ آﻨﻴﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫”‪source =“C:VBExamplesFiles.txt‬‬ ‫”‪destination =“D:MasteringVBNewName.txt‬‬ ‫)‪FileCopy(source,destination‬‬ ‫اﻳﻦ دﺳـﺘﻮرات، ﻓﺎﻳـﻞ ‪ Files.txt‬را ﺑـﻪ ﻣﻜـﺎن ﺟﺪﻳـﺪي آﭙـﻲ آـﺮدﻩ و ﻧـﺎم ﻓﺎﻳـﻞ آﭙـﻲ ﺷـﺪﻩ را ﺑـﻪ‬ ‫‪ NewName.txt‬ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ.‬ ‫هﻤﭽﻨﻴﻦ ﻣﻲ ﺗﻮاﻧﻴﺪ هﻤﺎن ﻧﺎم ﻗﺒﻠﻲ ﻓﺎﻳﻞ را ﺑﻨﻮﻳﺴﻴﺪ.‬ ‫)‪Rename(oldpath,newpath‬‬ ‫ﺑﺎ آﻤﻚ اﻳﻦ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻧﺎم ﻳﻚ ﻓﺎﻳﻞ ﻳﺎ ﭘﻮﺷﻪ را ﺗﻐﻴﻴﺮ دهﻴﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،oldpath‬ﻧﺎم و ﻣﺴﻴﺮ ﻓﺎﻳﻞ ﻳﺎ ﭘﻮﺷﻪ اي را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ ﻗﺮار اﺳﺖ ﺗﻐﻴﻴﺮ ﻧـﺎم ﭘﻴـﺪا‬ ‫آﻨﺪ و ﻧﺎم ﺟﺪﻳﺪ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺁرﮔﻮﻣﺎن ‪ newpath‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)”‪Rename(“C:Users”,“C:All Users‬‬ ‫اﻳﻦ دﺳﺘﻮر، ﭘﻮﺷﻪ ‪ Users‬را در دراﻳﻮ ‪ C‬ﺑﻪ ‪ All Users‬ﺗﻐﻴﻴﺮ ﻧﺎم ﻣﻲ دهﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٥١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 16.
    ‫ﻧﻜﺎت ﻣﻬﻢ دراﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ:‬ ‫ﺗﻐﻴﻴﺮ ﻧﺎم ﭘﻮﺷﻪ، ﺗﺎﺛﻴﺮي در ﺷﺎﻣﻞ ﺑﻮدن زﻳﺮﭘﻮﺷﻪ هﺎ و ﻓﺎﻳﻞ هﺎ در ﺁن ﻧﺪارد.‬ ‫اﮔﺮ ﺷﻤﺎ ﻗﺼﺪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ دو ﭘﻮﺷﻪ ﺗﻮ در ﺗﻮ را هﻤﺰﻣﺎن ﺗﻐﻴﻴﺮ ﻧﺎم دهﻴﺪ ﻳﻚ ﺧﻄـﺎ رخ ﺧﻮاهـﺪ‬ ‫داد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل:‬ ‫)”1‪Rename(“C:Users New User”, “C:All Users User‬‬ ‫ﺑﺎ اﺟﺮاي اﻳﻦ دﺳﺘﻮر، ﻳﻚ ﺧﻄﺎ اﺗﻔﺎق ﺧﻮاهﺪ اﻓﺘﺎد.‬ ‫ﺑﺮاي ﺗﻐﻴﻴﺮ ﻧﺎم دو ﻳﺎ ﭼﻨﺪ ﭘﻮﺷﻪ ي ﺗﻮ در ﺗﻮ ﺑﺎﻳﺪ ﺁﻧﻬﺎ را ﻳﻜﻲ ﻳﻜﻲ ﺗﻐﻴﻴﺮ ﻧﺎم دهﻴﺪ.‬ ‫ﺗﺎﺑﻊ ‪ Rename‬هﻤﭽﻨﻴﻦ در ﺻﻮرت ﻧﻴﺎز، در هﻨﮕﺎم ﺗﻐﻴﻴﺮ ﻧﺎم ﻳﻚ ﻓﺎﻳﻞ ﻗﺎدر ﺑﻪ اﻧﺘﻘﺎل ﺁن )‪ (Cut‬ﺑﻪ‬ ‫ﻳﻚ ﻣﻜﺎن ﺟﺪﻳﺪ ﺑﺮ روي هﺎرددﻳﺴﻚ اﺳﺖ.‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ اﻳﻦ ﺗﺎﺑﻊ ﻗﺎدر ﺑﻪ اﻧﺘﻘﺎل ﭘﻮﺷﻪ هﺎ ﻧﻴﺴﺖ.‬ ‫ﺑﻪ ﻋﻨﻮام ﻣﺜﺎل ﻓﺮﻣﺎن زﻳﺮ ﻓﺎﻳﻞ ‪ Profile1.cps‬را در ﻣﺴﻴﺮ ﻣﺸﺨﺺ ﺷﺪﻩ در دراﻳﻮ ‪ C‬هﻤﺮاﻩ ﺑﺎ‬ ‫ﺗﻐﻴﻴﺮ ﻧﺎم ﺁن ﺑﻪ ‪ UserProfile.cps‬ﺑﻪ ﻣﺴﻴﺮ ﻣﺸﺨﺺ ﺷﺪﻩ در دراﻳﻮ ‪ D‬ﻣﻨﺘﻘﻞ ﻣﻲ آﻨﺪ:‬ ‫)”‪Rename(“C:AllUsersUser1Profile1.cps”, “D:New UserUserProfile.cps‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻗﺎدر ﺑﻪ اﻳﺠﺎد ﻳﻚ ﭘﻮﺷﻪ ي ﺟﺪﻳﺪ ﻧﻴﺴﺖ.‬ ‫ﺗﺎﺑﻊ ‪ Reaname‬ﺑﺮ روي ﻓﺎﻳﻞ هﺎي ﺑﺎز ﻳﺎ ﻓﺎﻳﻞ هﺎﻳﻲ آـﻪ ﺗﻮﺳـﻂ ﺑﺮﻧﺎﻣـﻪ هـﺎي دﻳﮕـﺮ، هﻤﺰﻣـﺎن در‬ ‫ﺣﺎل اﺳﺘﻔﺎدﻩ هﺴﺘﻨﺪ آﺎرﺑﺮد ﻧﺪارد.‬ ‫در اﻳﻦ ﺗﺎﺑﻊ ﻣﺠﺎز ﺑﻪ اﺳﺘﻔﺎدﻩ از آﺎراآﺘﺮهﺎي ﺟﺎﻳﮕﺰﻳﻦ)* و ؟( ﻧﻴﺴﺘﻴﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٦١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 17.
    ‫)‪:(Data Type Identification‬‬ ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺮاي ﺷﻨﺎﺳﺎﻳﻲ ﻧﻮع دادﻩ هﺎ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‬ ‫ﺗﻮاﺑﻊ ﻣﻮﺟﻮد در اﻳﻦ ﺑﺨﺶ، ﺗﻨﻬﺎ ﻧﻮع دادﻩ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﻨﺪ.‬ ‫)‪IsArray(variable‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ ﻳﻚ ﻣﺘﻐﻴﺮ از ﻧﻮع ﺁراﻳﻪ اﺳﺖ ﻳﺎ ﺧﻴﺮ. ﭼﻨﺎﻧﭽـﻪ از ﻧـﻮع ﺁراﻳـﻪ ﺑﺎﺷـﺪ، ﺗـﺎﺑﻊ‬ ‫ﻣﻘﺪار ‪ True‬و ﮔﺮﻧﻪ ‪ False‬را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ variable‬ﻧﺎم ﻣﺘﻐﻴﺮي اﺳﺖ آﻪ ﺑﺎﻳﺪ ﺑﺮرﺳﻲ ﺷﻮد.‬ ‫ﻣﺜﺎل هﺎي زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)001(‪Dim names‬‬ ‫)‪IsArray(names‬‬ ‫ﺧﺮوﺟﻲ اﻳﻦ ﺗﺎﺑﻊ ‪ True‬اﺳﺖ ﭼﻮن آﻪ ‪ names‬ﺑﻪ ﻋﻨﻮان ﻳﻚ ﺁراﻳﻪ ٠٠١ ﺗﺎﻳﻲ ﺗﻌﺮﻳﻒ ﺷﺪﻩ اﺳﺖ.‬ ‫‪Dim A As Integer‬‬ ‫)‪IsArray(A‬‬ ‫ﺧﺮوﺟﻲ ﺗﺎﺑﻊ در اﻳﻦ ﺣﺎﻟﺖ، ‪ False‬اﺳﺖ زﻳﺮا ‪ A‬ﻣﺘﻐﻴﺮي از ﻧﻮع ﺻﺤﻴﺢ ﺗﻌﺮﻳﻒ ﺷﺪﻩ اﺳﺖ.‬ ‫)‪IsDate(expression‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ اﺳﺖ ﻳﺎ ﺧﻴﺮ. ﭼﻨﺎﻧﭽﻪ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ ﺑﺎﺷﺪ،‬ ‫ﺗﺎﺑﻊ ‪ True‬و ﮔﺮﻧﻪ ‪ False‬را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ expression‬ﻋﺒﺎرﺗﻲ اﺳﺖ آﻪ ﺑﺎﻳﺪ ﭼﻚ ﺷﻮد.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)”‪BDate =InputBox(“Please enter your birth date‬‬ ‫‪If IsDate(BDate)Then‬‬ ‫”‪MsgBox “Date accepted‬‬ ‫‪End If‬‬ ‫)‪IsDBNull(expression‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ در ﺻﻮرﺗﻲ آﻪ ﻳﻚ ﻣﻘﺪار، ‪ DBNull‬ﺑﺎﺷﺪ، ﻣﻘﺪار ‪ True‬را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫‪ DBValue‬ﻣﻘﺪاري اﺳﺖ آﻪ وﺟﻮد ﻧﺪارد و ﺑﺎ ﻣﻘﺪار ‪ Nothing‬ﺗﻔﺎوت دارد.‬ ‫‪ DBValue‬ﻧﻤﺎﻳﺎﻧﮕﺮ ﺁن اﺳﺖ آﻪ از ذآﺮ ﻳﻚ ﻣﻘﺪار ﺧﻮدداري ﺷﺪﻩ و ﻳﺎ ﻧﻮع ﺁن ﺗﻌﺮﻳﻒ ﻧﺸﺪﻩ.‬ ‫)‪IsNothing(expression‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ ﺁﻳﺎ ﻣﻘﺪاري )ﻣﺘﻐﻴﺮي( آﻪ از ﻧﻮع ‪) Object‬ﺷـﻲ( ﺗﻌﺮﻳـﻒ ﺷـﺪﻩ داراي‬ ‫ﻣﻘﺪار اﺳﺖ ﻳﺎ ﺧﻴﺮ. اﮔـﺮ ﻣﻘـﺪاراي ﺑـﻪ ﺁن ﻧـﺴﺒﺖ دادﻩ ﺷـﺪﻩ ﺑﺎﺷـﺪ، ﺧﺮوﺟـﻲ ﺗـﺎﺑﻊ ‪ True‬و ﮔﺮﻧـﻪ‬ ‫‪ False‬اﺳﺖ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫‪Dim obj As Object‬‬ ‫ﺑﻌﺪ از اﻳﻦ ﺗﻌﺮﻳﻒ، ﺧﺮوﺟﻲ ﻋﺒﺎرت )‪ IsNothing(obj‬ﺑﺮاﺑﺮ ‪ True‬اﺳـﺖ ﭼـﻮن هﻨـﻮز ﻣﻘـﺪاري ﺑـﻪ‬ ‫ﻣﺘﻐﻴﺮ ﻣﺎ ﻧﺴﺒﺖ دادﻩ ﻧﺸﺪﻩ اﺳﺖ.‬ ‫ﺣﺎﻻ ﻣﺎ ﻳﻚ ﻣﻘﺪار از ﻧﻮع ‪) Object‬ﺷﻲ( را ﺑﻪ اﻳﻦ ﻣﺘﻐﻴﺮ ﻧﺴﺒﺖ ﻣﻲ دهﻴﻢ:‬ ‫)21,21,001,01(‪obj =New Rectangle‬‬ ‫ﺑﻌﺪ از اﺟﺮاي اﻳﻦ دﺳﺘﻮر، ﻣﺘﻐﻴﺮ ﻣﺎ داراي ﻣﻘﺪار اﺳﺖ و ﺧﺮوﺟﻲ ﻋﺒـﺎرت )‪ IsNothing(obj‬ﺑﺮاﺑـﺮ‬ ‫‪ False‬ﻣﻲ ﺑﺎﺷﺪ.‬ ‫در اﻳﻦ ﻣﺜﺎل ﻣﻲ ﺗﻮان ﺑﺎ ﻧﻮﺷﺘﻦ ﻓﺮﻣﺎن ‪ ،Set obj=Nothing‬ﻓﻀﺎي اﺷﻐﺎل ﺷـﺪﻩ ﺣﺎﻓﻈـﻪ را آـﻪ‬ ‫ﺑﺮاي اﻳﺠﺎد اﻳﻦ ﺷﻲ در اﺧﺘﻴﺎر ﺑﺮﻧﺎﻣﻪ ﻗﺮار ﮔﺮﻓﺘﻪ اﺳﺖ ﺑﻪ ﺣﺎﻓﻈﻪ اﺻﻠﻲ ﺑﺮﮔﺮداﻧﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٧١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 18.
    ‫ﺑﻪ دو ﺷﻜﻞﻣﻲ ﺗﻮان اﻳﻦ ﺗﺎﺑﻊ را ﺑﻪ آﺎر ﺑﺮد:‬ ‫١( ‪If IsNothing(obj) Then‬‬ ‫٢( ‪If obj Is Nothing Then‬‬ ‫در ﺷﻜﻞ دوم، از آﻠﻤﻪ ي آﻠﻴﺪي )‪ (Is‬اﺳﺘﻔﺎدﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫)‪IsNumeric(expression‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ رﺷﺘﻪ را ﺗﺴﺖ ﻣﻲ آﻨﺪ و ﭼﻨﺎﻧﭽﻪ آﻠﻴﻪ آﺎراآﺘﺮهﺎي رﺷﺘﻪ، ارﻗﺎم ﺑﻴﻦ 0 ﺗﺎ 9 ﺑﺎﺷـﻨﺪ،‬ ‫ﻣﻘﺪار ‪ True‬و ﮔﺮﻧﻪ ﻣﻘﺪار ‪ False‬را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)”‪age =InputBox(“Please enter your age‬‬ ‫‪If Not IsNumeric(age)Then‬‬ ‫)”‪MsgBox(“Please try again,this time with a valid number‬‬ ‫‪End If‬‬ ‫در اﻳﻦ ﻣﺜﺎل ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ ،InputBox‬ﺳﻦ آﺎرﺑﺮ درﺧﻮاﺳﺖ ﻣـﻲ ﺷـﻮد و ﺳـﭙﺲ ﻣﻘـﺪار‬ ‫ورودي آﺎرﺑﺮ ﺑﺎ ﺗﺎﺑﻊ )(‪ IsNumeric‬ﭼﻚ ﻣﻲ ﺷـﻮد. ﭼﻨﺎﻧﭽـﻪ آـﺎرﺑﺮ آـﺎراآﺘﺮي ﻏﻴـﺮ ﻋـﺪدي را وارد‬ ‫آﺮدﻩ ﺑﻮد، ﺑﻪ او اﻃﻼع دادﻩ ﻣﻲ ﺷﻮد.‬ ‫)‪IsReference(expression‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آـﻪ ﻳـﻚ ﻣﺘﻐﻴـﺮ از ﻧـﻮع ‪ Object‬ﻳـﺎ ‪ Reference‬اﺿـﺎﻓﻪ ﺷـﺪﻩ ﺑـﻪ ﺑﺮﻧﺎﻣـﻪ‬ ‫اﺳﺖ ﻳﺎ ﺧﻴﺮ و ﺧﺮوﺟﻲ ﺁن ﻳﺎ ‪ True‬و ﻳﺎ ‪ False‬اﺳﺖ.‬ ‫)‪TypeName(variable_name‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻧﻮع ﻳﻚ ﻣﺘﻐﻴﺮ را ﺑﻪ ﺻﻮرت رﺷﺘﻪ اي ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻣﻤﻜﻦ اﺳﺖ ﻣﺘﻐﻴﺮي آﻪ ﺷﻤﺎ ﻣﻲ ﺧﻮاهﻴﺪ ﻧﻮع ﺁن را ﺑﺎ اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ دﺳﺖ ﺁورﻳﺪ، ﺗﻌﺮﻳـﻒ ﺷـﺪﻩ ﻳـﺎ‬ ‫ﻧﺸﺪﻩ ﺑﺎﺷﺪ.‬ ‫ﻓﺮض ﻣﻲ آﻨﻴﻢ آﻪ ﻣﺘﻐﻴﺮهﺎي زﻳﺮ ﺗﻌﺮﻳﻒ ﺷﺪﻩ اﻧﺪ:‬ ‫‪Dim name As Integer‬‬ ‫‪Dim a‬‬ ‫دﺳﺘﻮرات زﻳﺮ ﻧﺘﺎﻳﺞ زﻳﺮ را ﺗﻮﻟﻴﺪ ﻣﻲ آﻨﻨﺪ:‬ ‫))‪Console.WriteLine(TypeName(name‬‬ ‫‪Integer‬‬ ‫))‪Console.WriteLine(TypeName(a‬‬ ‫‪Nothing‬‬ ‫”‪a =“I ’m a string‬‬ ‫))‪Console.WriteLine(TypeName(a‬‬ ‫‪String‬‬ ‫)‪VarType(variable‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻧﻮع ﻳﻚ ﻣﺘﻐﻴﺮ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ هﻤﺎﻧﻨﺪ ﺗﺎﺑﻊ )(‪ TypeName‬ﻋﻤﻞ ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ اﻳﻦ ﺗﺎﺑﻊ، ﻳـﻚ ﻣﻘـﺪار ﻋـﺪدي‬ ‫را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ وﻟﻲ ﺗﺎﺑﻊ ‪ TypeName‬ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي را ﺑﺮﮔﺸﺖ ﺧﻮاهﺪ داد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،Variable‬ﻣﺘﻐﻴﺮي اﺳﺖ آﻪ ﻧﻮع ﺁن ﺑﺎﻳﺪ ﻣﺸﺨﺺ ﺷﻮد.‬ ‫ﻣﻘﺎدﻳﺮي آﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ در زﻳﺮ ﻟﻴﺴﺖ ﺷﺪﻩ اﺳﺖ:‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٨١‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 19.
    ‫ ﺑﺮﮔﺸﺖ ﻣﻲدهﺪ‬VarType() ‫ﻣﻘﺎدﻳﺮي آﻪ ﺗﺎﺑﻊ‬ ‫ﻣﻘﺪار‬ Array Boolean Byte Char Currency DataObject Date Decimal Double Empty Error Integer Long Null Object Short Single String UserDefinedType Variant .‫ ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﺪ ﺷﺪ‬VarType() ‫ﻣﻘﺪار ﺛﺎﺑﺖ ﻋﺪدي اﻳﻦ ﻣﻘﺎدﻳﺮ ﺗﻮﺳﻂ ﺗﺎﺑﻊ‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ١٩ Visual Basic.NET ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ‬
  • 20.
    ‫)‪:(Variable Type Conversion‬‬ ‫ﺗﻮاﺑﻊ ﺗﺒﺪﻳﻞ ﻧﻮع ﻣﺘﻐﻴﺮ‬ ‫ﻣﺘﻐﻴﺮهﺎ ﻗﺎﺑﻠﻴﺖ ﺗﺒﺪﻳﻞ ﺷﺪن ﺑﻪ ﻳﻜﺪﻳﮕﺮ را دارﻧﺪ.‬ ‫ﺗﻤﺎﻣﻲ ﺗﻮاﺑﻊ اﻳﻦ ﺑﺨﺶ ﺁرﮔﻮﻣﺎن هﺎي ﻋﺪدي ﻣﻲ ﭘﺬﻳﺮﻧﺪ و ﺁﻧﻬﺎ را ﺗﺒﺪﻳﻞ ﺑﻪ ﻧﻮع دﻳﮕﺮي از ﻣﺘﻐﻴﺮهـﺎ‬ ‫ﻣﻲ آﻨﻨﺪ.‬ ‫اﻳﻦ ﺗﻮاﺑﻊ را در ﺟﺪول زﻳﺮ ﻣﺸﺎهﺪﻩ ﻣﻲ آﻨﻴﺪ:‬ ‫ﺗﻮاﺑﻊ ﺗﺒﺪﻳﻞ ﻧﻮع ﻣﺘﻐﻴﺮ‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻧﺎم ﺗﺎﺑﻊ‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Boolean‬‬ ‫) ‪CBool(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Byte‬‬ ‫) ‪CByte(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Char‬‬ ‫) ‪CChar(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Date‬‬ ‫) ‪CDate(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Decimal‬‬ ‫) ‪CDec(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Double‬‬ ‫) ‪CDbl(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Integer‬‬ ‫) ‪CInt(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Long‬‬ ‫) ‪CLng(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Object‬‬ ‫) ‪CObj(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Short‬‬ ‫) ‪Cshort(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪Single‬‬ ‫) ‪CSng(expression‬‬ ‫ﺗﺒﺪﻳﻞ ﺑﻪ ‪String‬‬ ‫) ‪CStr(expression‬‬ ‫ﻧﻮع ﺳﻔﺎرﺷﻲ‬ ‫) ‪CType(expression,type‬‬ ‫)‪CType(varName,typeName‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻣﻘﺪار ﻳﺎ ﻋﺒﺎرت را آﻪ ﻣﻘﺪار ﺁن در ﺁرﮔﻮﻣﺎن ‪ varName‬ﺗﻌﻴﻴﻦ ﺷﺪﻩ ﺑﻪ ﻧـﻮﻋﻲ آـﻪ در‬ ‫ﺁرﮔﻮﻣﺎن ‪ typeName‬ﻣﺸﺨﺺ ﺷﺪﻩ ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ.‬ ‫دﺳﺘﻮرات زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)‪CType(1000, System.Double‬‬ ‫)‪CType(“1000”, System.Double‬‬ ‫اوﻟﻴﻦ دﺳﺘﻮر، ﻣﻘﺪار ٠٠٠١ را آﻪ از ﻧﻮع ﻋﺪد ﺻﺤﻴﺢ )‪ (Integer‬اﺳﺖ و دﺳﺘﻮر دوم ﻣﻘﺪار ٠٠٠١‬ ‫را آﻪ از ﻧﻮع رﺷﺘﻪ اي )‪ (String‬اﺳﺖ ﺑﻪ ﻧﻮع ﻋﺪد اﻋﺸﺎري ﺑﺎ دﻗﺖ ﻣﻀﺎﻋﻒ )‪ (Double‬ﺗﺒـﺪﻳﻞ‬ ‫ﻣﻲ آﻨﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٠٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 21.
    ‫)‪:(String Manipulation‬‬ ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ رﺷﺘﻪ هﺎ ﺳﺮ و آﺎر دارﻧﺪ‬ ‫در ‪ VB.NET‬ﺗﻮاﺑﻊ ﺑﺴﻴﺎر ﻣﻬﻢ، ﻣﻔﻴﺪ و آﺎرﺁﻣﺪي ﺟﻬﺖ آﺎر ﺑﺎ رﺷﺘﻪ هﺎ وﺟﻮد دارﻧﺪ.‬ ‫ﻣﻴﺎﻧﮕﻴﻨﻲ آﻪ در راﺑﻄﻪ ﺑﺎ ﻋﻤﻠﻜﺮد ﺑﺮﻧﺎﻣﻪ هﺎي آﺎرﺑﺮدي ﮔﺮﻓﺘـﻪ ﺷـﺪﻩ ﻧـﺸﺎن ﻣـﻲ دهـﺪ آـﻪ ﺗﻮاﺑـﻊ‬ ‫رﺷﺘﻪ اي ﺑﻴﺶ از ﺗﻮاﺑﻊ ﻋﺪدي آﺎرﺑﺮد دارﻧﺪ.‬ ‫در اﻳﻦ ﺑﺨﺶ دو ﺗﺎﺑﻊ هﻤﻨﺎم ﺑﻪ ﻧﺎم هﺎي )(‪ Mid‬و ‪ Mid‬وﺟﻮد دارد آـﻪ ﻋﻤﻠﻜـﺮدي ﺷـﺒﻴﻪ ﺑـﻪ هـﻢ‬ ‫داﺷﺘﻪ و در ﺟﺎي ﺧﻮد ﺑﺤﺚ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫ﺗﻤـــــﺎﻣﻲ ﺗﻮاﺑـــــﻊ رﺷـــــﺘﻪ اي ‪ VB.NET‬داراي ﻣﺘــــ ـﺪ و ﺧـــــﻮاص ﻣـــــﺸﺎﺑﻪ و ﺑﺮاﺑــــ ـﺮ ي در‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫آﻼس ‪ System.String‬هﻤﺎﻧﻨﺪ آﻼس ‪ StringBuilder‬هﺴﺘﻨﺪ.‬ ‫)‪Asc(character) , AscW(string‬‬ ‫ﺗﺎﺑﻊ )(‪ ،Asc‬آﺪ اﺳﻜﻲ ﻳﻚ آﺎراآﺘﺮ را آﻪ ﻧـﺎم در ﺁرﮔﻮﻣـﺎن ‪ character‬ذآـﺮ ﺷـﺪﻩ، ﺑﺮﮔـﺸﺖ ﻣـﻲ‬ ‫دهﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺑﺮ روي هﻤﻪ ﺳﻴﺴﺘﻢ هﺎ آﺎر ﻣﻲ آﻨـﺪ ﺣﺘـﻲ اﮔـﺮ ﺁن ﺳﻴـﺴﺘﻢ از ‪ Unicode‬ﭘـﺸﺘﻴﺒﺎﻧﻲ‬ ‫ﻧﻜﻨﺪ.‬ ‫اﮔﺮ در ﺁرﮔﻮﻣﺎن ‪ character‬ﺑﻪ ﺟﺎي آﺎراآﺘﺮ، ﻳﻚ آﻠﻤﻪ ﻳﺎ رﺷﺘﻪ ﺁوردﻩ ﺷﻮد، اوﻟﻴﻦ آـﺎراآﺘﺮ رﺷـﺘﻪ‬ ‫در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫ﺗﺎﺑﻊ )(‪ AscW‬ﻋﻤﻠﻜﺮدي ﺷﺒﻴﻪ ﺑﻪ ﺗﺎﺑﻊ )(‪ Asc‬دارد ﺑﺎ اﻳـﻦ ﺗﻔـﺎوت آـﻪ آـﺪ اﺳـﻜﻲ آـﺎراآﺘﺮ را ﺑـﻪ‬ ‫ﺻﻮرت ‪ Unicode‬ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ در ﺻـﻮرﺗﻲ آـﻪ ﺗـﺎﺑﻊ )(‪ Asc‬آـﺪ اﺳـﻜﻲ را ﺑـﻪ ﺻـﻮرت ﺑﺎﻳـﺖ‬ ‫ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫از اﻳﻦ ﺗﻮاﺑﻊ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺟﻬﺖ ﺗﺒﺪﻳﻞ آﺎراآﺘﺮ آﻠﻴﺪ ﻓﺸﺮدﻩ ﺷﺪﻩ ﺗﻮﺳﻂ آﺎرﺑﺮ ﺑﻪ آﺪ اﺳـﻜﻲ ﻣﻌـﺎدل‬ ‫ﺁن اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﺑـﻪ ﻋﻨـﻮان ﻣﺜـﺎل ﻧﺘﻴﺠـﻪ ﺧﺮوﺟـﻲ )”‪ ،ASC(“Ali‬ﻋـﺪد 56 اﺳـﺖ و ﻧﺘﻴﺠـﻪ ﺧﺮوﺟـﻲ )”‪،ASC(“N‬‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ﻋﺪد 87 اﺳﺖ.‬ ‫)‪Chr(number) , ChrW(number‬‬ ‫اﻳﻦ دو ﺗﺎﺑﻊ دﻗﻴﻘﺎ ﻋﻜﺲ ﺗﻮاﺑﻊ )(‪ Asc‬و )(‪ AscW‬ﻋﻤﻞ ﻣﻲ آﻨﻨﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ ،Chr‬آﺎراآﺘﺮ ﻣﻌﺎدل آﺪ اﺳﻜﻲ ﻳﻚ ﻋﺪد از ﻧﻮع ﺑﺎﻳﺖ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫از اﻳﻦ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺟﻬﺖ ﭼﺎپ ﺣﺮوف ﻳـﺎ آﺎراآﺘﺮهـﺎﻳﻲ آـﻪ ﺑـﺮ روي ﺻـﻔﺤﻪ آﻠﻴـﺪ وﺟـﻮد ﻧﺪارﻧـﺪ‬ ‫هﻤﺎﻧﻨﺪ ﺷﻜﻠﻚ هﺎ ﻳﺎ ﺣﺮوﻓﻲ آﻪ آﺪ اﺳﻜﻲ ﺁﻧﻬﺎ از 721 ﺑﻴﺸﺘﺮ اﺳﺖ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ ChrW‬ﻧﻴﺰ ﻳﻚ آﺎراآﺘﺮ از ﻧﻮع ‪ Unicode‬ﻳﻚ ﻣﻘﺪار ﻋﺪدي را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫از اﻳﻦ ﺗﻮاﺑﻊ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺟﻬﺖ ﺗﺒﺪﻳﻞ آﺪ اﺳﻜﻲ آﻠﻴﺪ ﻓﺸﺮدﻩ ﺷﺪﻩ ﺗﻮﺳﻂ آﺎرﺑﺮ ﺑﻪ آـﺎراآﺘﺮ ﻣﻌـﺎدل‬ ‫ﺁن اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫)‪LCase(string) , UCase(string‬‬ ‫ﺗﺎﺑﻊ )(‪ ،Lcase‬در ﻳﻚ رﺷﺘﻪ، ﺣﺮوف ﺑﺰرگ رﺷﺘﻪ را ﺑﻪ ﺣﺮوف آﻮﭼﻚ ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ ،Ucase‬در ﻳﻚ رﺷﺘﻪ، ﺣﺮوف آﻮﭼﻚ رﺷﺘﻪ را ﺑﻪ ﺣﺮوف ﺑﺰرگ ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫”‪Title =“Visual Basic.Net‬‬ ‫)‪LTitle =LCase(Title‬‬ ‫)‪UTitle =UCase(Title‬‬ ‫ﺑﻌﺪ از اﺟﺮاي اﻳﻦ دﺳﺘﻮرات ﻣﺘﻐﻴﺮهﺎي ‪ Ltitle‬و ‪ ،Utitle‬داراي ﻣﻘﺎدﻳﺮ زﻳﺮ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫"‪Ltitle=”visual basic.net‬‬ ‫”‪Utitle=”VISUAL BASIC.NET‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫١٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 22.
    ‫)] ‪InStr([startPos,] string1,string2[,compare‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، زﻳﺮرﺷﺘﻪ اي را در رﺷﺘﻪ دﻳﮕﺮ ﺟﺴﺘﺠﻮ آﺮدﻩ و ﻣﺤﻞ وﺟـﻮد زﻳﺮرﺷـﺘﻪ در رﺷـﺘﻪ را ﺑﺮﻣـﻲ‬ ‫ﮔﺮداﻧﺪ.‬ ‫اوﻟﻴﻦ ﺁرﮔﻮﻣﺎن، اﺧﺘﻴﺎري اﺳﺖ و ﻣﻜﺎﻧﻲ از رﺷﺘﻪ اﺳﺖ آﻪ ﺟـﺴﺘﺠﻮ ﺑﺎﻳـﺪ از ﺁﻧﺠـﺎ ﺁﻏـﺎز ﺷـﻮد. اﮔـﺮ‬ ‫ذآﺮ ﻧﺸﻮد 1 در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد و ﺟﺴﺘﺠﻮ از اﺑﺘﺪاي رﺷﺘﻪ ﺁﻏﺎز ﺧﻮاهﺪ ﺷﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺁرﮔﻮﻣﺎن 2‪ string‬را در ﺁرﮔﻮﻣﺎن 1‪ string‬ﺟﺴﺘﺠﻮ ﻣﻲ آﻨﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫”‪str1 =“The quick brown fox jumped over the lazy dog‬‬ ‫”‪str2 =“the‬‬ ‫)2‪Pos =Instr(str1, str‬‬ ‫ﺑﻌﺪ از اﺟﺮاي دﺳﺘﻮرات ﻓﻮق، ﻣﺘﻐﻴﺮ ‪ Pos‬داراي ﻣﻘﺪار 33 ﺧﻮاهﺪ ﺷﺪ.‬ ‫ﻧﻜﺎت ﻣﻬﻢ:‬ ‫١( اﮔﺮ رﺷﺘﻪ اي آﻪ ﺟﺴﺘﺠﻮ ﺑﺮاي ﺁن ﺁﻏﺎز ﻣﻲ ﺷﻮد ﺑﻴﺶ از ﻳـﻚ ﺑـﺎر در رﺷـﺘﻪ ﺟـﺴﺘﺠﻮ ﺷـﻮﻧﺪﻩ‬ ‫ﺗﻜﺮار ﺷﺪﻩ ﺑﺎﺷﺪ و آﻠﻤﻪ ﺑﺎﺷﺪ، ﻣﺤﻞ ﺁﺧﺮﻳﻦ وﺟﻮد ﺁن ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد هﻤﺎن ﻃﻮر آﻪ در‬ ‫اﻳﻦ ﻣﺜﺎل آﻠﻤﻪ ‪ ،the‬دوﺑﺎر ﺗﻜﺮار ﺷﺪﻩ اﺳﺖ اﻣﺎ اﮔﺮ ﻗـﺴﻤﺘﻲ از ﻳـﻚ آﻠﻤـﻪ ﺑﺎﺷـﺪ، ﺣﺘـﻲ اﮔـﺮ‬ ‫ﭼﻨﺪﻳﻦ ﺑﺎر هﻢ ﺗﻜﺮار ﺷﺪﻩ ﺑﺎﺷﺪ، ﻣﺤﻞ اوﻟﻴﻦ وﻗﻮع ﺁن ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﺪ ﺷﺪ.‬ ‫٢(ﺟﺴﺘﺠﻮ ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ آﻮﭼﻚ ﻳﺎ ﺑﺰرگ ﺑـﻮدن ﺣـﺮوف اﻧﺠـﺎم ﺧﻮاهـﺪ ﺷـﺪ ﻳﻌﻨـﻲ‬ ‫ﻓﺮﺿﺎ آﻠﻤﺎت ‪ The ،the‬و ‪ THE‬ﺑﺎ هﻢ ﺗﻔﺎوت دارﻧﺪ.‬ ‫و اﻳﻦ ﺗﻨﻈﻴﻢ ﺑﻪ وﺳﻴﻠﻪ ﺗﻐﻴﻴﺮ ﺁﺧـﺮﻳﻦ ﺁرﮔﻮﻣـﺎن ﻳﻌﻨـﻲ ‪ compare‬آـﻪ ﺑـﻪ ﻃـﻮر ﭘـﻴﺶ ﻓـﺮض ﻣﻘـﺪار‬ ‫‪ CompareMethod.Binary‬را دارد ﻣﻲ ﺗﻮاﻧﺪ ﺗﻐﻴﻴﺮ آﻨﺪ.‬ ‫ﺑـــﺮاي اﻳﻨﻜـــﻪ ﺑـــﺰرگ ﻳـــﺎ آﻮﭼـــﻚ ﺑـــﻮدن ﺣـــﺮوف، در ﺟـــﺴﺘﺠﻮ ﻧﺎدﻳـــﺪﻩ ﮔﺮﻓﺘـــﻪ ﺷـــﻮد، ﻣﻘـــﺪار‬ ‫ﺁرﮔﻮﻣﺎن ‪ Compare‬را ﺑﻪ ‪ CompareMethod.Text‬ﺗﻐﻴﻴﺮ دهﻴﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫”‪str1 =“The quick brown fox jumped over the lazy dog‬‬ ‫”‪str2 =“the‬‬ ‫)‪Pos =InStr(1, str1, str2, CompareMethod.Text‬‬ ‫ﭘــﺲ از اﺟــﺮاي اﻳــﻦ دﺳــﺘﻮرات ﻣﻘــﺪار ﻣﺘﻐﻴــﺮ ‪ 1 ،pos‬ﺧﻮاهــﺪ ﺷــﺪ. در ﺻــﻮرﺗﻲ آــﻪ ﺁرﮔﻮﻣــﺎن‬ ‫‪ compare‬را ﺑﻪ ‪ CompareMethod.Binary‬ﺗﻐﻴﻴﺮ دهﻴﻢ ﻣﻘﺪار ﻣﺘﻐﻴﺮ ‪ 33 ،pos‬ﺧﻮاهﺪ ﺷﺪ.‬ ‫)] ‪InStrRev(string1,string2 [,start ][,compare‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ هﻤﺎﻧﻨـﺪ ﺗـﺎﺑﻊ )(‪ InStr‬ﻋﻤـﻞ ﻣـﻲ آﻨـﺪ ﺑـﺎ اﻳـﻦ ﺗﻔـﺎوت آـﻪ در ﺗـﺎﺑﻊ )(‪ InStr‬ﺟـﺴﺘﺠﻮ از‬ ‫اﺑﺘﺪاي رﺷﺘﻪ )ﭼﭗ ﺑﻪ راﺳـﺖ( وﻟـﻲ در ﺗـﺎﺑﻊ ‪ InStrRev‬ﺟـﺴﺘﺠﻮ از اﻧﺘﻬـﺎي رﺷـﺘﻪ )راﺳـﺖ ﺑـﻪ‬ ‫ﭼﭗ( اﻧﺠﺎم ﻣﻲ ﺷﻮد.‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﺟﺎي ﺁرﮔﻮﻣﺎن ‪ start‬در اﻳﻦ ﺗﺎﺑﻊ ﻋﻮض ﺷﺪﻩ.‬ ‫)] ‪StrComp(string1,string2 [,compare‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، دو رﺷﺘﻪ را ﺑﺎ ﻳﻜﺪﻳﮕﺮ ﻣﻘﺎﻳﺴﻪ آﺮدﻩ و ﺣﺎﺻﻞ ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن هﺎي 1‪ string‬و 2‪ string‬رﺷﺘﻪ هـﺎﻳﻲ هـﺴﺘﻨﺪ آـﻪ ﺑﺎﻳـﺪ ﺑـﺎ ﻳﻜـﺪﻳﮕﺮ ﻣﻘﺎﻳـﺴﻪ ﺷـﻮﻧﺪ و‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،compare‬روش ﻣﻘﺎﻳﺴﻪ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ.‬ ‫اﮔﺮ دو رﺷﺘﻪ ﺑﺎ هﻢ ﺑﺮاﺑﺮ ﺑﺎﺷﻨﺪ، ﺗﺎﺑﻊ ﻣﻘﺪار 0 را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫اﮔﺮ رﺷﺘﻪ اول ﺑﺰرﮔﺘﺮ از رﺷﺘﻪ دوم ﺑﺎﺷﺪ، ﺗﺎﺑﻊ ﻣﻘﺪار 1 را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫اﮔﺮ رﺷﺘﻪ دوم ﺑﺰرﮔﺘﺮ از رﺷﺘﻪ اول ﺑﺎﺷﺪ، ﺗﺎﺑﻊ ﻣﻘﺪار 1– را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﺑﺎ در ﻧﻈﺮ ﮔﺮﻓﺘﻦ ﺑﺰرگ ﻳﺎ آﻮﭼﻚ ﺑﻮدن ﺣﺮوف اﻧﺠﺎم ﻣﻲ ﺷﻮد.‬ ‫ﺑـــﺮاي اﻳﻨﻜـــﻪ ﺑـــﺰرگ ﻳـــﺎ آﻮﭼـــﻚ ﺑـــﻮدن ﺣـــﺮوف، در ﻣﻘﺎﻳـــﺴﻪ ﻧﺎدﻳـــﺪﻩ ﮔﺮﻓﺘـــﻪ ﺷـــﻮد، ﻣﻘـــﺪار‬ ‫ﺁرﮔﻮﻣﺎن ‪ Compare‬را ﺑﻪ ‪ CompareMethod.Text‬ﺗﻐﻴﻴﺮ دهﻴﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٢٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 23.
    ‫)”‪Result=StrComp(“Sybex”, “SYBEX‬‬ ‫ﭘﺲ ازاﺟﺮاي اﻳﻦ دﺳﺘﻮر، ﻣﻘﺪار ‪ 1 ،Result‬ﺧﻮاهﺪ ﺷﺪ زﻳـﺮا ﻋﺒـﺎرت ‪ Sybex‬از ‪ SYBEX‬ﺑﺰرﮔﺘـﺮ‬ ‫اﺳﺖ و اﻳﻦ ﺑﺪان ﻋﻠﺖ اﺳﺖ آﻪ در ﺗﺮﺗﻴﺐ ﺣﺮوف اﺳﻜﻲ )‪ ،(ASCII‬ﺣﺮف ‪ y‬آﻮﭼﻚ ﺑﻌﺪ از ﺣﺮف ‪Y‬‬ ‫ﺑﺰرگ ﻗﺮار دارد. ﺑﻪ ﻋﺒﺎرت دﻳﮕﺮ ﺣﺮوف آﻮﭼﻚ ﺑﺮ ﺣﺮوف ﺑﺰرگ ارﺟﻌﻴﺖ دارﻧﺪ.‬ ‫ﻣﺜﺎل دﻳﮕﺮ:‬ ‫)‪Result=StrComp(“Sybex”, “SYBEX”, CompareMethod.Text‬‬ ‫اﻳﻦ هﻤﺎن ﻣﺜﺎل ﻗﺒﻠﻲ اﺳﺖ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ در اﻳﻦ ﻣﺜﺎل، ﺑﺰرگ و آﻮﭼﻚ ﺑـﻮدن ﺣـﺮوف ﺗـﺎﺛﻴﺮي در‬ ‫ﻧﺘﻴﺠﻪ ﻣﻘﺎﻳﺴﻪ ﻧﺨﻮاهﺪ داﺷﺖ ﭘﺲ دو رﺷﺘﻪ در اﻳﻦ ﺣﺎل ﺑﺎ ﻳﻜﺪﻳﮕﺮ ﺑﺮاﺑـﺮ ﺑـﻮدﻩ و ﻣﻘـﺪار ‪،Result‬‬ ‫0 ﺧﻮاهﺪ ﺷﺪ.‬ ‫)‪Left(string,number‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، از ﺳﻤﺖ ﭼﭗ ﻳﻚ رﺷﺘﻪ، رﺷﺘﻪ اي ﺑﺎ ﻃﻮل ﻣﻌﻴﻦ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،string‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺑﺎﻳﺪ رﺷﺘﻪ اي ﺑﻪ ﻃﻮل ﺗﻌﻴﻴﻦ ﺷـﺪﻩ در ﺁرﮔﻮﻣـﺎن ‪number‬‬ ‫از ﺳﻤﺖ ﭼﭗ ﺁن ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫”‪StrX=”Visual Basic.NET‬‬ ‫)6 ,‪StrGet=Left(StrX‬‬ ‫ﭘﺲ از اﺟﺮاي دﺳﺘﻮرات ﻓﻮق، 6 آﺎراآﺘﺮ اول از ﺳﻤﺖ ﭼﭗ ﻣﺘﻐﻴـﺮ ‪ StrX‬در ﻣﺘﻐﻴـﺮ ‪ StrGet‬ﻗـﺮار‬ ‫ﺧﻮاهﺪ ﮔﺮﻓﺖ و ﻣﻘﺪار ﻣﺘﻐﻴﺮ ‪ ،StrGet‬ﺑﺮاﺑﺮ ﺑﺎ ”‪ “Visual‬ﺧﻮاهﺪ ﺷﺪ.‬ ‫)‪Right(string,number‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، از ﺳﻤﺖ راﺳﺖ ﻳﻚ رﺷﺘﻪ، رﺷﺘﻪ اي ﺑﺎ ﻃﻮل ﻣﻌﻴﻦ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،string‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺑﺎﻳﺪ رﺷﺘﻪ اي ﺑﻪ ﻃﻮل ﺗﻌﻴﻴﻦ ﺷـﺪﻩ در ﺁرﮔﻮﻣـﺎن ‪number‬‬ ‫از ﺳﻤﺖ راﺳﺖ ﺁن ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫”‪StrX=”Visual Basic.NET‬‬ ‫)3 ,‪StrGet=Right(StrX‬‬ ‫ﭘﺲ از اﺟﺮاي دﺳﺘﻮرات ﻓـﻮق، 3 آـﺎراآﺘﺮ اول از ﺳـﻤﺖ راﺳـﺖ ﻣﺘﻐﻴـﺮ ‪ StrX‬در ﻣﺘﻐﻴـﺮ ‪StrGet‬‬ ‫ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ و ﻣﻘﺪار ﻣﺘﻐﻴﺮ ‪ ،StrGet‬ﺑﺮاﺑﺮ ﺑﺎ ”‪ “NET‬ﺧﻮاهﺪ ﺷﺪ.‬ ‫)] ‪Mid(string,start,[length‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺑﺨﺸﻲ از ﻳﻚ رﺷﺘﻪ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ string‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺑﺎﻳﺪ ﺑﺨﺸﻲ از ﺁن ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ start‬ﻣﻜﺎﻧﻲ از رﺷﺘﻪ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ اﺳﺘﺨﺮاج رﺷﺘﻪ ﺑﺎﻳـﺪ از ﺁن ﻣﻜـﺎن ﺷـﺮوع‬ ‫ﺷﻮد و ﺁرﮔﻮﻣﺎن ‪ length‬ﻃﻮل رﺷﺘﻪ ﺑﺮﮔﺸﺘﻲ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ.‬ ‫ﻧﻜﺎت ﻣﻬﻢ:‬ ‫١( اﺳﺘﺨﺮاج رﺷﺘﻪ از ﺳﻤﺖ ﭼﭗ ﺑﻪ راﺳﺖ اﻧﺠﺎم ﻣﻲ ﺷﻮد.‬ ‫٢( اﮔﺮ از ذآﺮ ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ length‬ﺧﻮدداري ﺷﻮد، ﺗﻤﺎﻣﻲ آﺎراآﺘﺮهﺎ از ﻣﻜﺎﻧﻲ آـﻪ ﺗﻮﺳـﻂ‬ ‫ﺁرﮔﻮﻣﺎن ‪ start‬ﻣﺸﺨﺺ ﺷﺪﻩ ﺗﺎ ﺑﻪ ﺁﺧﺮ رﺷﺘﻪ اﺳﺘﺨﺮاج ﻣﻲ ﺷﻮﻧﺪ.‬ ‫٣( اﮔﺮ ﻣﻘﺪار ﺁرﮔﻮﻣﺎن ‪ length‬ﺑﻴﺶ از ﺗﻌﺪاد آﺎراآﺘﺮهـﺎﻳﻲ ﺑﺎﺷـﺪ آـﻪ ﺑﻌـﺪ از ﺁرﮔﻮﻣـﺎن ‪ start‬در‬ ‫رﺷﺘﻪ وﺟﻮد دارﻧﺪ، ﺗﻤﺎﻣﻲ آﺎراآﺘﺮهﺎي ﻣﺸﺨﺺ ﺷﺪﻩ در رﺷﺘﻪ، از ﻣﻜـﺎن ‪ Start‬ﺗـﺎ ﺑـﻪ اﻧﺘﻬـﺎ‬ ‫ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫‪Mid(string,start [,length ])=new_string‬‬ ‫در ﺣﺎﻟﺖ ﭘﻴﺸﺮﻓﺘﻪ ﺗﺎﺑﻊ )(‪ Mid‬اﻳﻦ ﺗﺎﺑﻊ وﺟﻮد دارد آﻪ ﺗﺎ ﺣﺪي ﺷﺒﻴﻪ ﺑـﻪ ﺗـﺎﺑﻊ )(‪ Mid‬ﻋﻤـﻞ ﻣـﻲ‬ ‫آﻨﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٣٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 24.
    ‫اﻳﻦ ﺗﺎﺑﻊ رﺷﺘﻪاي را در ﻳﻚ رﺷﺘﻪ دﻳﮕﺮ ﺟﺎﻳﮕﺰﻳﻦ ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ string‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﻣﻘـﺪار ‪ new_String‬ﺑﺎﻳـﺪ در ﺁن ﺟـﺎﻳﮕﺰﻳﻦ ﺷـﻮد و ﺁرﮔﻮﻣـﺎن‬ ‫‪ Start‬ﻣﻮﻗﻌﻴﺘﻲ از ﺁرﮔﻮﻣﺎن )رﺷﺘﻪ( ‪ string‬را ﻣـﺸﺨﺺ ﻣـﻲ آﻨـﺪ آـﻪ ﻋﻤـﻞ ﺟـﺎﻳﮕﺰﻳﻨﻲ ﺑﺎﻳـﺪ از‬ ‫ﺁﻧﺠﺎ ﺷﺮوع ﺷﻮد و ﺁرﮔﻮﻣﺎن ‪ ،length‬ﻃﻮل رﺷﺘﻪ اي را آﻪ ﺑﺎﻳﺪ ﺟﺎﻳﮕﺰﻳﻦ ﺷﻮد ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ.‬ ‫ﻧﻜﺎت ﻣﻬﻢ:‬ ‫١( اﮔﺮ از ذآﺮ ﻣﻘﺪار ‪ new_string‬ﺧﻮدداري ﺷﻮد، ﺗﻤﺎﻣﻲ آﺎراآﺘﺮهـﺎ در رﺷـﺘﻪ از ﻧﻘﻄـﻪ ﺗﻌﻴـﻴﻦ‬ ‫ﺷﺪﻩ در ﺁن ﺗﺎ ﺑﻪ اﻧﺘﻬﺎ ﺟﺎﻳﮕﺰﻳﻦ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫٢( اﮔﺮ ﺑﺮﻧﺎﻣﻪ اي ﻣﻲ ﻧﻮﻳﺴﻴﺪ آﻪ ﺑﺎ رﺷﺘﻪ هﺎي ﻃﻮﻻﻧﻲ و ﻣﺘﻦ هﺎي زﻳﺎد ﺳـﺮ و آـﺎر دارد ﺣﺘﻤـﺎ‬ ‫از آﻼس ‪ StringBuilder‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﻣﺘﻐﻴﺮهﺎي آﻼس ‪ StringBuilder‬از ﻧﻮع ﻣﺘﻨﻲ)‪ (Text‬هﺴﺘﻨﺪ و آﺎﻣﭙـﺎﻳﻠﺮ ‪ .NET‬ﺑـﺴﻴﺎر ﺑﻬﺘـﺮ از‬ ‫ﻣﺘﻐﻴﺮهﺎي رﺷﺘﻪ اي )‪ (String‬ﻗﺎدر ﺑﻪ آﺎر ﺑﺎ ﺁﻧﻬﺎﺳﺖ. )آﻼس ﺑﺮﻧﺎﻣﻪ را هﻤﻴﺸﻪ ﺣﻔﻂ آﻨﻴﺪ!(‬ ‫)‪Len(string‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻃﻮل ﻳﻚ رﺷﺘﻪ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،string‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﻃﻮل ﺁن ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﻣﺜﺎل:‬ ‫)”‪Name =InputBox(“Enter your first name‬‬ ‫)‪NameLen =Len(Name‬‬ ‫ﺑﻌﺪ از اﺟﺮاي اﻳﻦ دﺳﺘﻮرات، ﻣﻘﺪار ﻣﺘﻐﻴﺮ ‪ ،NameLen‬ﻃـﻮل رﺷـﺘﻪ اي اﺳـﺖ آـﻪ آـﺎرﺑﺮ در آـﺎدر‬ ‫ﻣﺤﺎورﻩ )(‪ InputBox‬وارد آﺮدﻩ.‬ ‫از اﻳﻦ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺮاي ﭼـﻚ آـﺮدن اﻳﻨﻜـﻪ ﺁﻳـﺎ آـﺎرﺑﺮ ﻣﻘـﺪاري را در ﻣﻜـﺎﻧﻲ واردﻩ آـﺮدﻩ ﻳـﺎ ﻧـﻪ،‬ ‫اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل:‬ ‫‪If Len(Text1.Text) = 0 Then‬‬ ‫)”‪MsgBox (“Name field can ’t be empty‬‬ ‫‪Else‬‬ ‫)”‪MsgBox (“Thank you for registering‬‬ ‫‪EndIf‬‬ ‫در اﻳﻦ دﺳﺘﻮرات، ﻣﻘﺪار ‪ TextBox‬ﭼﻚ ﻣﻲ ﺷـﻮد آـﻪ ﺁﻳـﺎ آـﺎرﺑﺮ ﭼﻴـﺰي در ﺁن وارد آـﺮدﻩ ﻳـﺎ ﻧـﻪ و‬ ‫ﺳﭙﺲ ﭘﻴﻐﺎم ﻣﻨﺎﺳﺐ ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ Len‬ﻗﺎدر ﺑﻪ درﻳﺎﻓﺖ هﺮ ﻧﻮع ﻣﻘﺪار ﻏﻴﺮ رﺷﺘﻪ اي ﻧﻴﺰ در ﺁرﮔﻮﻣﺎن ‪ string‬ﺧﻮد ﻣﻲ ﺑﺎﺷﺪ.‬ ‫در اﻳﻦ ﺣﺎﻟﺖ ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ ﺗﺎﺑﻊ، ﺗﻌﺪاد ﺑﺎﻳﺖ هﺎي ﻣـﻮرد ﻧﻴـﺎز ﺟﻬـﺖ ﻧﮕﻬـﺪاري ﻣﻘـﺪار وارد‬ ‫ﺷﺪﻩ در ﺣﺎﻓﻈﻪ ﻣﻲ ﺑﺎﺷﺪ ﻧﻪ ﻃﻮل ﺁن.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل:‬ ‫)10.21(‪Len‬‬ ‫در ‪ ،VB.NET‬ﻣﻘﺎدﻳﺮ اﻋﺸﺎري ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض از ﻧﻮع ‪) Double‬اﻋﺸﺎري ﺑﺎ دﻗـﺖ ﻣـﻀﺎﻋﻒ(‬ ‫در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد ﭘﺲ ﺧﺮوﺟـﻲ ﺗـﺎﺑﻊ در اﻳـﻦ ﺣﺎﻟـﺖ، ﻋـﺪد 8 ﻳﻌﻨـﻲ ﺗﻌـﺪاد ﺑﺎﻳـﺖ هـﺎي ﻻزم‬ ‫ﺟﻬﺖ ﻧﮕﻬﺪاري ﻳﻚ ﻣﻘﺪار از ‪ Double‬در ﺣﺎﻓﻈﻪ ﺧﻮاهﺪ ﺑﻮد.‬ ‫و ﺑﻪ ﻋﻨﻮان ﺁﺧﺮﻳﻦ ﻣﺜﺎل:‬ ‫)21(‪Len‬‬ ‫در اﻳﻦ ﺣﺎﻟﺖ ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ، 4 ﺧﻮاهﺪ ﺑﻮد. زﻳﺮا ﻣﻴـﺰان ﻓـﻀﺎي ﻻزم ﺟﻬـﺖ ﻧﮕﻬـﺪاري ﻳـﻚ ﻋـﺪد از‬ ‫ﻧﻮع ‪ 4 ،Integer‬ﺑﺎﻳﺖ اﺳﺖ.‬ ‫)‪LTrim(string),RTrim(string),Trim(string‬‬ ‫اﻳﻦ ﺗﻮاﺑﻊ، ﻓﻀﺎهﺎي ﺧﺎﻟﻲ ﻳﻚ رﺷﺘﻪ را هﺮ آﺪام ﺑﻪ ﻧﺤﻮي ﺣﺬف ﻣﻲ آﻨﻨﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ ،LTrim‬ﻓﻀﺎي ﺧﺎﻟﻲ ﺳﻤﺖ ﭼﭗ ﻳﻚ رﺷﺘﻪ را ﺣﺬف ﻣﻲ آﻨﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ ،RTrim‬ﻓﻀﺎي ﺧﺎﻟﻲ ﺳﻤﺖ راﺳﺖ ﻳﻚ رﺷﺘﻪ را ﺣﺬف ﻣﻲ آﻨﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ ،Trim‬ﻓﻀﺎي ﺧﺎﻟﻲ ﺳﻤﺖ ﭼﭗ و راﺳﺖ ﻳﻚ رﺷﺘﻪ را ﺣﺬف ﻣﻲ آﻨﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٤٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 25.
    ‫ﺁرﮔﻮﻣﺎن ‪ string‬درهﺮ ﺳﻪ ﺗﺎﺑﻊ، رﺷﺘﻪ اي اﺳﺖ آﻪ ﻓﻀﺎي ﺧﺎﻟﻲ ﺁن ﺑﺎﻳﺪ ﺣﺬف ﺷﻮد.‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ هﺮ ﺳﻪ ي اﻳﻦ ﺗﻮاﺑﻊ، ﻣﻘﺪاري رﺷﺘﻪ اي و از ﻧـﻮع ‪ String‬ﻣـﻲ ﺑﺎﺷـﺪ و ﻋﺒـﺎرﺗﻲ‬ ‫اﺳﺖ آﻪ ﻓﻀﺎهﺎي ﺧﺎﻟﻲ ﺁن ﺑﻨﺎ ﺑﻪ ﻧﻮع ﺗﺎﺑﻊ، ﺣﺬف ﺷﺪﻩ اﺳﺖ.‬ ‫آﺎرﺑﺮد اﻳﻦ ﺗﺎﺑﻊ ﻣﻌﻤﻮﻻ در ﭼـﻚ آـﺮدن ﻣﻘـﺎدﻳﺮ ورودي ﺗﻮﺳـﻂ آـﺎرﺑﺮ ﺑـﺮاي ﺗـﺸﺨﻴﺺ ﺧـﺎﻟﻲ ﻧﺒـﻮدن‬ ‫ﻣﻘﺪار ورودي اﺳﺖ.‬ ‫ﻣﺜﻼ دﺳﺘﻮرات زﻳﺮ ﭼﻚ ﻣﻲ آﻨﺪ آﻪ ﺁﻳـﺎ ﻣﻘـﺪار ﻣﺘﻐﻴـﺮ ‪ ،E_Mail‬ﺧـﺎﻟﻲ اﺳـﺖ ﻳـﺎ ﺧﻴـﺮ و در ﺻـﻮرت‬ ‫ﺧﺎﻟﻲ ﺑﻮدن ﺁن ﭘﻴﻐﺎﻣﻲ ﻇﺎهﺮ ﻣﻲ ﮔﺮدد.‬ ‫‪If E_Mail = “” Then‬‬ ‫)”‪MsgBox (“Applications without an e-mail address won ’t be processed‬‬ ‫‪End If‬‬ ‫ﺣﺎل در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ آﻪ آﺎرﺑﺮ ﺑﻪ ﺟﺎي ﺗﺎﻳﭗ آﺎراآﺘﺮي در ﻣﻜﺎن ﻣﻮرد ﻧﻈﺮ،ﻳﻚ ﻳـﺎ ﭼﻨـﺪﻳﻦ ﺑـﺎر از آﻠﻴـﺪ‬ ‫‪ Space‬اﺳﺘﻔﺎدﻩ آﻨﺪ. از ﺁﻧﺠﺎ آـﻪ ‪ Space‬ﻧﻴـﺰ ﻧـﻮﻋﻲ آـﺎراآﺘﺮ اﺳـﺖ ﭘـﺲ دﺳـﺘﻮرات ﺑـﺎﻻ آـﺎرﺑﺮد‬ ‫ﻧﺪارد.‬ ‫ﭘﺲ در اﻳﻦ ﺣﺎﻟﺖ ﺑﺮاي دﻗﺖ ﭼﻚ آﺮدن ﺑﺎﻳﺪ از ﺗﻮاﺑﻊ ﺑﺎﻻ اﺳﺘﻔﺎدﻩ آﺮد.‬ ‫ﻣﻌﻤﻮﻻ ﺗﺎﺑﻊ )(‪ Trim‬از دو ﺗﺎﺑﻊ دﻳﮕﺮ آﺎرﺑﺮد ﺑﻴﺸﺘﺮي دارد.‬ ‫ﭘﺲ دﺳﺘﻮرات ﺑﺎﻻ را ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺻﻼح ﻣﻲ آﻨﻴﻢ:‬ ‫‪If Trim(E_Mail)=“” Then‬‬ ‫)”!‪MsgBox (“Invalid Entry‬‬ ‫‪End If‬‬ ‫)‪Space(number‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ رﺷﺘﻪ آﺎراآﺘﺮي از ﻓﻀﺎي ﺧﺎﻟﻲ )‪ (Blanck‬اﻳﺠﺎد ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،number‬ﺗﻌﺪاد آﺎراآﺘﺮ ﻓﻀﺎي ﺧﺎﻟﻲ اﺳﺖ آﻪ ﺑﺎﻳﺪ اﻳﺠﺎد ﺷﻮد.‬ ‫اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ ﺧﺮوﺟﻲ هﺎي ﺑﺮﻧﺎﻣﻪ و اﻳﺠـﺎد ﺑـﺎﻓﺮ ﺑـﺮاي ﺑﺮﺧـﻲ از ﺗﻮاﺑـﻊ‬ ‫‪ API‬ﻣﻔﻴﺪ اﺳﺖ.‬ ‫)‪StrDup(number,character‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ آﺎراآﺘﺮ را در ﻳﻚ رﺷﺘﻪ ﺑﻪ ﺗﻌﺪاد ﻣﻌﻴﻦ ﺑﺎر ﺗﻜﺮار ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ number‬ﻋﺪدي اﺳﺖ آﻪ ﺗﻌـﺪاد ﺗﻜـﺮار آـﺎراآﺘﺮ را آـﻪ ﺑـﻪ وﺳـﻴﻠﻪ ﺁرﮔﻮﻣـﺎن ‪character‬‬ ‫ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد، ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ character‬ﻣﻲ ﺗﻮاﻧﺪ آﺎراآﺘﺮ ﻳﺎ آﺪ اﺳﻜﻲ ﺑﺎﺷﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺟﺎﻳﮕﺰﻳﻦ ﺗﺎﺑﻊ )(‪ String‬در 0.6.‪ VB‬ﺷﺪﻩ اﺳﺖ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)”*“ ,21(‪Result=StrDup‬‬ ‫ﺑﺎ اﺟﺮاي اﻳﻦ دﺳﺘﻮر، آﺎراآﺘﺮ )*( ﺑﻪ ﺗﻌﺪاد 21 ﺑﺎر ﺗﻜـﺮار ﺧﻮاهـﺪ ﺷـﺪ و ﻧﺘﻴﺠـﻪ در ﻣﺘﻐﻴـﺮ ‪Result‬‬ ‫ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ. ﻳﻌﻨﻲ ﻣﺘﻐﻴﺮ ‪ Result‬داراي ﻣﻘﺪار زﻳﺮ ﺧﻮاهﺪ ﺷﺪ:‬ ‫”************”=‪Result‬‬ ‫)‪StrConv(string,conversion‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي را آﻪ ﺑﻪ ﺷﻜﻞ دﻳﮕﺮي ﺗﺒﺪﻳﻞ ﺷﺪﻩ اﺳﺖ ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،string‬رﺷﺘﻪ اي اﺳـﺖ آـﻪ ﺑﺎﻳـﺪ ﺗﺒـﺪﻳﻞ ﺷـﻮد و ﺁرﮔﻮﻣـﺎن ‪ conversion‬ﻧـﻮع ﺗﺒـﺪﻳﻞ را‬ ‫ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ ﻣﻲ ﺗﻮاﻧﺪ ﻳﻜﻲ از ﻣﻮارد زﻳﺮ ﺑﺎﺷﺪ:‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ convesion‬در ﺗﺎﺑﻊ )(‪StrConv‬‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻣﻘﺪار‬ ‫ﺗﻤﺎﻣﻲ آﺎراآﺘﺮهﺎي ﻣﻮﺟﻮد در رﺷﺘﻪ ﺑـﻪ ﺣـﺮوف‬ ‫‪UpperCase‬‬ ‫ﺑﺰرگ ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫ﺗﻤﺎﻣﻲ آﺎراآﺘﺮهﺎي ﻣﻮﺟﺪ در رﺷـﺘﻪ ﺑـﻪ ﺣـﺮوف‬ ‫‪LowerCase‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٥٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 26.
    ‫آﻮﭼﻚ ﺗﺒﺪﻳﻞ ﻣﻲﺷﻮﻧﺪ.‬ ‫اوﻟﻴﻦ آﺎراآﺘﺮ هﺮ آﻠﻤﻪ در رﺷﺘﻪ ﺑﻪ ﺣﺮف ﺑـﺰرگ‬ ‫‪ProperCase‬‬ ‫ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮد.‬ ‫آﺎراآﺘﺮهﺎي ﺗﻚ ﺑﺎﻳﺘﻲ در رﺷﺘﻪ ﺑﻪ آﺎراآﺘﺮهـﺎي‬ ‫‪Wide Narrow‬‬ ‫دوﺑﺎﻳﺘﻲ ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ‬ ‫آﺎراآﺘﺮهﺎي دوﺑﺎﻳﺘﻲ در رﺷـﺘﻪ ﺑـﻪ آﺎراآﺘﺮهـﺎي‬ ‫‪Narrow‬‬ ‫ﺗﻚ ﺑﺎﻳﺘﻲ ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫آﺎراآﺘﺮهـــ ـﺎي ‪ Hiragana‬ﺑـــ ـﻪ آﺎراآﺘﺮهـــ ـﺎي‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫‪Katakana‬‬ ‫‪ Katakana‬ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫آﺎراآﺘﺮهــــﺎي ‪ Katakana‬ﺑــــﻪ آﺎراآﺘﺮهــــﺎي‬ ‫‪Hiragana‬‬ ‫‪ Hiragana‬ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫آﺎراآﺘﺮهـ ـﺎي ﺳـ ـﺎدﻩ ﭼﻴﻨـ ـﻲ ﺑـ ـﻪ آﺎراآﺘﺮهـ ـﺎي‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫‪Traditional‬‬ ‫ﺳﻨﺘﻲ ﭼﻴﻨﻲ ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫آﺎراآﺘﺮهــﺎي ﺳــﻨﺘﻲ ﭼﻴﻨــﻲ ﺑــﻪ آﺎراآﺘﺮهــﺎي‬ ‫‪Simplified‬‬ ‫ﺳﺎدﻩ ﭼﻴﻨﻲ ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮﻧﺪ‬ ‫ﺑﺮاي ﺗﺒﺪﻳﻞ هﺎي ﭼﻨﺪﺗﺎﻳﻲ ﻣﻲ ﺗﻮاﻧﻴﺪ اﻳﻦ ﻣﻘﺎدﻳﺮ را ﺑﺎ ﻋﻼﻣﺖ + ﺑﺎ هﻢ ‪ AND‬آﻨﻴﺪ.‬ ‫ﺑﻪ ﻣﺜﺎل زﻳﺮ ﺗﻮﺟﻪ آﻨﻴﺪ:‬ ‫)‪newString =StrConv(MyString, vbStrConv.LowerCase + vbStrConv.Unicode‬‬ ‫در اﻳﻦ دﺳﺘﻮر، ﻋﺒﺎرت ﻣﻮﺟﻮد در ﻣﺘﻐﻴـﺮ ‪ ،MyString‬ﺑـﻪ ﺣـﺮوف آﻮﭼـﻚ و ﻗﺎﻟـﺐ ‪ Unicode‬ﺗﺒـﺪﻳﻞ‬ ‫ﺧﻮاهﺪ ﺷﺪ.‬ ‫)‪StrReverse(string‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي را ﻣﻌﻜﻮس ﻣﻲ آﻨﺪ.‬ ‫ﻣﺜﺎل:‬ ‫)”‪Result=StrReverse(“VisualBasic‬‬ ‫ﭘﺲ از اﺟﺮاي اﻳﻦ دﺳﺘﻮر، ﻣﻘﺪار ﻣﺘﻐﻴﺮ ‪ Result‬ﺑﺮاﺑﺮ ﺑﺎ ”‪ “lausiVcisaB‬ﺧﻮاهﺪ ﺷﺪ.‬ ‫)] ‪Filter(inputStrings,value [,include ][,compare‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺑﻴﺎن ﺳﺎدﻩ ﻳﻚ رﺷﺘﻪ ﻳﺎ زﻳﺮرﺷﺘﻪ را در ﻳﻚ ﺁراﻳﻪ رﺷـﺘﻪ اي ﺟـﺴﺘﺠﻮ آـﺮدﻩ و در ﺻـﻮرت‬ ‫ﭘﻴﺪا آﺮدن ﺁن، ﻳﻚ ﺁراﻳﻪ را ﺑﻪ ﻋﻨﻮان ﺧﺮوﺟﻲ ﻣﻲ دهﺪ آﻪ ﺧﺎﻧﻪ ﻳﺎ ﺧﺎﻧﻪ هﺎي ﺁن ﺗﺎ اﻧﺪﻳﺲ ﻣﻘﺪاري‬ ‫آﻪ در ﺁراﻳﻪ اﺻﻠﻲ ﭘﻴﺪا ﺷﺪﻩ و ﺑﺎ ﺁن ﻣﻘﺪار ﭘﺮ ﻣﻲ ﺷﻮد.‬ ‫در ﺣﻘﻴﻘﺖ ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ آﻪ در ﺁراﻳﻪ ﻗﺮار ﻣﻲ ﮔﻴـﺮد، ﺷـﺎﻣﻞ ﻳﻜـﻲ از ﻣﻘـﺎدﻳﺮ ﺧﺎﻧـﻪ هـﺎي ﺁراﻳـﻪ‬ ‫ﺟﺴﺘﺠﻮ ﺷﻮﻧﺪﻩ اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،inputstring‬ﻳﻚ ﺁراﻳﻪ ﻳﻚ ﺑﻌﺪي و رﺷﺘﻪ اي اﺳﺖ آﻪ ﻋﻤﻞ ﺟﺴﺘﺠﻮ ﺑﺎﻳـﺪ در ﺁن اﻧﺠـﺎم‬ ‫ﺷﻮد. دﻗﺖ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ اﻳﻦ ﺁراﻳﻪ ﺣﺘﻤﺎ ﺑﺎﻳﺪ ﺑﻪ ﺻﻮرت ﻳﻚ ﺑﻌﺪي ﺗﻌﺮﻳﻒ ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ value‬ﻣﻘﺪاري رﺷﺘﻪ اي اﺳﺖ آﻪ ﺟﺴﺘﺠﻮ ﺑﺎﻳﺪ ﺑﺮاي ﺁن اﻧﺠﺎم ﺷﻮد.‬ ‫دو ﺁرﮔﻮﻣﺎن ﺁﺧﺮ، اﺧﺘﻴﺎري هﺴﺘﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ include‬ﻣﺸﺨﺺ ﻣﻲ آﻨﻪ آﻪ ﺁﻳﺎ آﻞ ﻣﻘﺪار ‪ value‬ﺑﺎﻳﺪ در ﺁراﻳﻪ ﺑﺎﺷﺪ ﻳـﺎ ﻗـﺴﻤﺘﻲ از ﺁن‬ ‫هﻢ ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ ﻋﻨﻮان ﺷﺮط ﺟﺴﺘﺠﻮ ﺑﻪ آﺎر رود و ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ ‪ True‬ﻳﺎ ‪ False‬را ﻣﻲ ﭘﺬﻳﺮد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،compare‬ﻧﻮع ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ و ﻣـﺸﺨﺺ ﻣـﻲ آﻨـﺪ آـﻪ ﺁﻳـﺎ ﺑـﺰرگ ﻳـﺎ‬ ‫آﻮﭼــﻚ ﺑــﻮدن ﺣــﺮوف ﺗــﺎﺛﻴﺮي در ﻣﻘﺎﻳــﺴﻪ و ﺟــﺴﺘﺠﻮ داﺷــﺘﻪ ﺑﺎﺷــﺪ ﻳــﺎ ﺧﻴــﺮ و ﻳﻜــﻲ از ﻣﻘــﺎدﻳﺮ‬ ‫‪) CompareMethod.Binary‬ﭘــــﻴﺶ ﻓــــﺮض ﻳﻌﻨــــﻲ در ﻧﻈــــﺮ ﮔﺮﻓﺘــــﻪ ﻣــــﻲ ﺷــــﻮد( و ﻳــــﺎ‬ ‫‪) CompareMethod.Text‬ﻳﻌﻨﻲ در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻧﻤﻲ ﺷﻮد( را ﻣﻲ ﭘﺬﻳﺮد.‬ ‫ﺗﻌﺪاد ﺧﺎﻧﻪ هﺎي ﺁراﻳﻪ ي ﺑﺮﮔﺸﺖ دادﻩ ﺷﺪﻩ ﺑﺴﺘﮕﻲ ﺑﻪ اﻧﺪﻳﺲ ﻣﺤﻞ وﺟﻮد رﺷﺘﻪ اي اﺳـﺖ آـﻪ‬ ‫در ﺁراﻳﻪ ﭘﻴﺪا ﺷﺪﻩ. ﻓﺮﺿﺎ اﮔﺮ ﻣﻘﺪار ﻣﻮرد ﻧﻈﺮ ﻣﺎ در ﺧﺎﻧﻪ ي 4 ﺁراﻳﻪ ﭘﻴـﺪا ﺷـﺪ، ﺗﻌـﺪاد ﺧﺎﻧـﻪ هـﺎي‬ ‫ﺁراﻳﻪ ﺑﺮﮔﺸﺘﻲ 4 ﺧﺎﻧﻪ ﺧﻮاهﺪ ﺑﻮد.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٦٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 27.
    ‫ﭘﺲ، از ﺁﻧﺠﺎآﻪ ﺧﺎﻧﻪ اي آﻪ ﻣﻘﺪار ﻣﻮرد ﻧﻈﺮ در ﺁن ﭘﻴﺪا ﻣﻲ ﺷﻮد از ﻗﺒﻞ ﻗﺎﺑﻞ ﭘﻴﺶ ﺑﻴﻨﻲ ﻧﻴـﺴﺖ‬ ‫ﻧﺒﺎﻳﺪ ﺑﺮاي ﺧﺎﻧﻪ هﺎي ﺁراﻳﻪ ﺑﺮﮔﺸﺘﻲ، ﺗﻌﺪاد ﺗﻌﺮﻳﻒ آﻨﻴﻢ و ﻳﺎ ﺑﻪ ﻋﺒﺎرت دﻳﮕـﺮ ﺑﺎﻳـﺪ ﻳـﻚ ﺁراﻳـﻪ ﺑـﺪون‬ ‫ﺑﻌﺪ ﺗﻌﺮﻳﻒ آﻨﻴﻢ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫‪Dim selNames()As String‬‬ ‫}”‪Dim Names()As String ={“Ali”, “Mehdi”, “Mehdi”, “Behrouz”, “Sina‬‬ ‫در اﻳﻦ ﻣﺜﺎل، ﺁراﻳﻪ اي ﺑﻪ ﻧﺎم ‪ Names‬ﺗﻌﺮﻳﻒ ﺷﺪﻩ آﻪ ﭘﻨﺞ ﺧﺎﻧﻪ ي اول ﺁن ﺑﺎ 5 ﻣﻘـﺪار رﺷـﺘﻪ اي‬ ‫ﭘﺮ ﺷﺪﻩ اﺳﺖ. اﻳﻦ ﺁراﻳﻪ اي اﺳﺖ آﻪ ﻣﺎ در ﺁن ﻗﺼﺪ ﺟﺴﺘﺠﻮي ﻣﻘﺪار ﺧﻮد را دارﻳﻢ.‬ ‫ﺣﺎل ﻣﻲ ﺧﻮاهﻴﻢ ﻣﻘﺪار ذﺧﻴـﺮﻩ ﺷـﺪﻩ در ﻣﺘﻐﻴـﺮي رﺷـﺘﻪ اي ﺑـﻪ ﻧـﺎم ‪ myName‬را در اﻳـﻦ ﺁراﻳـﻪ‬ ‫ﺟﺴﺘﺠﻮ آﻨﻴﻢ. ﭘﺲ ﺗﺎﺑﻊ )(‪ Filter‬را ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ آﻨﻴﻢ:‬ ‫)‪selNames =Filter(Names,myName‬‬ ‫ﭘﺲ از اﺟﺮاي اﻳﻦ دﺳـﺘﻮر اﮔـﺮ ﻣﻘـﺪار ذﺧﻴـﺮﻩ ﺷـﺪﻩ در ﻣﺘﻐﻴـﺮ ‪ myName‬در ﺁراﻳـﻪ ﻧﺒﺎﺷـﺪ، در ﺁن‬ ‫ﺻﻮرت ﺁراﻳﻪ ‪ selNames‬آﻪ ﺁن را ﺑﻪ ﺻﻮرت ﺁراﻳﻪ اي ﺑﺪون ﺑﻌﺪ ﺗﻌﺮﻳﻒ آﺮدﻳﻢ ﺁراﻳﻪ اي ﺑـﺪون ﺧﺎﻧـﻪ‬ ‫ﺧﻮاهﺪ ﺑﻮد و ﻳﺎ ﺑﻪ ﻋﺒﺎرت دﻳﮕﺮ ﺧﺎﺻﻴﺖ ‪ Length‬ﺁن ﺑﺮاﺑﺮ ﺑﺎ 0 ﺧﻮاهﺪ ﺑﻮد.‬ ‫اﮔﺮ ﻣﻘﺪار ذﺧﻴـﺮﻩ ﺷـﺪﻩ در ﻣﺘﻐﻴـﺮ ‪ “Ali” ،myName‬ﺑﺎﺷـﺪ، ﺣـﺪ ﺑـﺎﻻي ﺁراﻳـﻪ ‪ selNames‬ﺻـﻔﺮ‬ ‫ﺧﻮاهﺪ ﺑﻮد و ﻣﻘﺪار اوﻟﻴﻦ ﺧﺎﻧﻪ ﺁراﻳﻪ ﺑﺮاﺑﺮ ﺑﺎ ”‪ “Ali‬ﻣﻲ ﺷﻮد ﻳﻌﻨﻲ: ”‪selNames(0)=”Ali‬‬ ‫اﮔﺮ ﻣﻘﺪار ذﺧﻴﺮﻩ ﺷﺪﻩ در ﻣﺘﻐﻴﺮ ‪ “Mehdi” ،myName‬ﺑﺎﺷﺪ، ﺣﺪ ﺑـﺎﻻي ﺁراﻳـﻪ ‪ ،selNames‬ﻳـﻚ‬ ‫ﺧﻮاهﺪ ﺑﻮد و ﻣﻘﺎدﻳﺮ ﺧﺎﻧﻪ هﺎي اول و دوم ﺁراﻳﻪ ﺑﺮاﺑﺮ ﺑﺎ ”‪ “Mehdi‬ﻣﻲ ﺷﻮد ﻳﻌﻨﻲ:‬ ‫”‪selNames(0)=”Mehdi‬‬ ‫”‪selNames(1)=”Mehdi‬‬ ‫)] ‪Replace(expression,find,replacewith [,start ][,count ][,compare‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ رﺷﺘﻪ را در رﺷﺘﻪ دﻳﮕـﺮ ﺟـﺴﺘﺠﻮ آـﺮدﻩ و رﺷـﺘﻪ ﺳـﻮم را ﺟـﺎﻳﮕﺰﻳﻦ رﺷـﺘﻪ ﺟـﺴﺘﺠﻮ‬ ‫ﺷﺪﻩ ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺑﺮاي ﺟﺎﻳﮕﺰﻳﻨﻲ ﺟﺴﺘﺠﻮ ﻣﻲ ﮔﺮدد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،find‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺟﺴﺘﺠﻮ ﻣﻲ ﮔﺮدد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،replacewith‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺟﺎﻳﮕﺰﻳﻦ رﺷﺘﻪ ﭘﻴﺪا ﺷﺪﻩ ﻣﻲ ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،start‬ﻋﺪدي اﺳﺖ آﻪ ﻣﻜﺎن ﺷﺮوع ﺟﺴﺘﺠﻮ در رﺷﺘﻪ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨـﺪ و اﮔـﺮ‬ ‫در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻧﺸﻮد، ﺟﺴﺘﺠﻮ از اﺑﺘﺪاي رﺷﺘﻪ ﺷﺮوع ﻣﻲ ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،count‬ﻣﻘﺪاري ﻋﺪدي اﺳﺖ آﻪ ﺗﻌﺪاد دﻓﻌﺎﺗﻲ را آﻪ ﺟﺎﻳﮕﺰﻳﻨﻲ ﺑﺎﻳﺪ اﻧﺠﺎم ﮔﻴﺮد، ﺗﻌﻴـﻴﻦ‬ ‫ﻣﻲ آﻨﺪ. اﮔﺮ ذآﺮ ﻧﺸﻮد، آﻠﻴﻪ ﺟﺎﻳﮕﺰﻳﻨﻲ هﺎ اﻧﺠﺎم ﺧﻮاهﺪ ﺷﺪ.‬ ‫و در ﻧﻬﺎﻳﺖ ﺁرﮔﻮﻣﺎن ‪ ،compare‬ﻧﻮع ﻣﻘﺎﻳﺴﻪ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آـﻪ در ﺗﻮاﺑـﻊ ﻗﺒﻠـﻲ در ﻣـﻮرد اﻳـﻦ‬ ‫ﺁرﮔﻮﻣﺎن ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫”‪S=”Visual Basic.NET as powerfull as C#.NET‬‬ ‫)”‪K=Replace (S, “NET”, “bes‬‬ ‫)‪Console.WriteLn(K‬‬ ‫ﺧﺮوﺟﻲ اﻳﻦ ﻗﻄﻌﻪ ﺑﺮﻧﺎﻣﻪ ﭘﺲ از اﺟﺮا ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺧﻮاهﺪ ﺑﻮد:‬ ‫”‪”Visual Basic.bes as powerfull as C#.bes‬‬ ‫)] ‪Join(list [,delimiter‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻣﻘﺎدﻳﺮ ﻣﻮﺟﻮد در ﻳﻚ ﺁراﻳﻪ ﻳﻚ ﺑﻌﺪي – رﺷﺘﻪ اي را ﺑﻪ ﺻﻮرت ﻳﻚ رﺷﺘﻪ و ﭘﺸﺖ ﺳﺮ هﻢ‬ ‫ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،list‬ﺁراﻳﻪ اي ﻳﻚ ﺑﻌﺪي و ﺷﺎﻣﻞ ﻣﻘﺎدﻳﺮي رﺷﺘﻪ اي اﺳـﺖ آـﻪ ﻗـﺼﺪ ﺑﺎزﮔـﺸﺖ ﺁﻧﻬـﺎ ﺑـﻪ‬ ‫ﺻﻮرت ﻳﻚ رﺷﺘﻪ را دارﻳﺪ و ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،delimiter‬ﻳﻚ آـﺎراآﺘﺮ رﺷـﺘﻪ اي اﺳـﺖ آـﻪ ﺑـﺮاي‬ ‫ﺟﺪا آﺮدن رﺷﺘﻪ هﺎ از هﻢ در ﻧﺘﻴﺠﻪ ﺧﺮوﺟﻲ ﺑـﻪ آـﺎر ﻣـﻲ رود و در ﺻـﻮرﺗﻲ آـﻪ ذآـﺮ ﻧـﺸﻮد، ﻳـﻚ‬ ‫ﻓﺎﺻﻠﻪ ﺧﺎﻟﻲ در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد و اﮔﺮ ﻣﻘﺪار ﺁن ﺗﻬﻲ ﻳﺎ ”“ ﺗﻌﻴﻴﻦ ﺷـﻮد، ﻣﻘـﺎدﻳﺮ ﺧﺎﻧـﻪ هـﺎي‬ ‫ﺁراﻳﻪ ﭘﺸﺖ ﺳﺮ هﻢ و ﺑﺪون ﻓﺎﺻﻠﻪ در ﺧﺮوﺟﻲ ﻇﺎهﺮ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫‪Dim MyArr(1 To 5) As String‬‬ ‫‪Dim Result As String‬‬ ‫”‪MyArr(1) = "Behrouz‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٧٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 28.
    ‫”‪MyArr(2) = "Rad‬‬ ‫)”|“,‪Result = Join(MyArr‬‬ ‫‪MsgBox Result‬‬ ‫ﺑﻌﺪ از اﺟﺮاي اﻳﻦ دﺳﺘﻮرات، ﺧﺮوﺟﻲ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ:‬ ‫”|||‪“Behrouz|Rad‬‬ ‫دﻗﺖ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ اﮔﺮ ﺗﻤﺎم ﺧﺎﻧﻪ هﺎي ﺁراﻳﻪ ﭘﺮ ﻧﺸﺪﻩ ﺑﺎﺷﻨﺪ، ﺑﻪ ﺟـﺎي ﺁﻧﻬـﺎ آـﺎراآﺘﺮي آـﻪ در‬ ‫ﺁرﮔﻮﻣﺎن ‪ delimiter‬ﺗﻌﻴﻴﻦ ﺷﺪﻩ ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ.‬ ‫ﺗﻌﺪاد آﺎراآﺘﺮهﺎي ‪ delimiter‬آﻪ ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ، ﺗﻌﺪاد ﺧﺎﻧﻪ هﺎي ﺁراﻳﻪ ﻣﻨﻬﺎي ﻳﻚ اﺳﺖ.‬ ‫)] ‪Split(expression [,delimiter ][,count ][,compare‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ رﺷﺘﻪ را ﺑﻪ ﺗﻌﺪادي زﻳﺮرﺷﺘﻪ ي آﻮﭼﻜﺘﺮ ﺗﻘﺴﻴﻢ آﺮدﻩ و هﺮ آﺪام را در ﻳﻜﻲ از ﺧﺎﻧـﻪ‬ ‫هﺎي ﺁراﻳﻪ ﻗﺮار ﻣﻲ دهﺪ و ﻳﺎ ﺑﻪ ﻋﺒﺎرت ﺑﻬﺘﺮ هﺮ آﺪام از آﻠﻤﺎت رﺷﺘﻪ را در ﻳﻚ ﺧﺎﻧﻪ ي ﺁراﻳـﻪ ﻗـﺮار‬ ‫ﻣﻲ دهﺪ.‬ ‫ﺧﺮوﺟﻲ اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﺁراﻳﻪ ﻳﻚ ﺑﻌﺪي اﺳﺖ آﻪ هـﺮ آـﺪام از ﺧﺎﻧـﻪ هـﺎي ﺁن داراي ﻳﻜـﻲ از ﻣﻘـﺎدﻳﺮ‬ ‫زﻳﺮرﺷﺘﻪ هﺎﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺑﺎﻳﺪ ﺑﻪ زﻳﺮرﺷﺘﻪ هﺎي آﻮﭼﻜﺘﺮ ﺗﻘﺴﻴﻢ ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،delimiter‬رﺷﺘﻪ اي اﺳﺖ آﻪ ﺗﻘﺴﻴﻢ ﺑﻨﺪي ﺑﺎﻳﺪ ﺑـﺮ اﺳـﺎس ﺁن اﻧﺠـﺎم ﺷـﻮد.‬ ‫اﮔﺮ ذآﺮ ﻧﺸﻮد ﻓﻀﺎي ﺧﺎﻟﻲ در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد وﻟﻲ اﮔﺮ ﺗﻬﻲ ﻳﺎ ”“ ذآﺮ ﺷﻮد، آﻞ رﺷـﺘﻪ در‬ ‫اوﻟﻴﻦ ﻋﻨﺼﺮ ﺁراﻳﻪ ﻗﺮار ﻣﻲ ﮔﻴﺮد.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ count‬ﻧﻴﺰ ﺗﻌﺪاد زﻳﺮرﺷﺘﻪ هﺎﻳﻲ را آﻪ ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷـﻮﻧﺪ ﻣـﺸﺨﺺ ﻣـﻲ‬ ‫آﻨﺪ.‬ ‫اﮔﺮ ﻣﻘﺪار ﺁن 1– ﺑﺎﺷﺪ، ﺗﻤﺎﻣﻲ زﻳﺮرﺷﺘﻪ هﺎ ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ compare‬آﻪ ﻧﻮع ﻣﻘﺎﻳﺴﻪ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ در ﺗﻮاﺑﻊ ﻗﺒﻠﻲ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫ﻓﺮض ﻣﻲ آﻨﻴﻢ ﻣﺘﻐﻴﺮي رﺷﺘﻪ اي ﺑﻪ ﻧﺎم ‪ path‬ﺗﻌﺮﻳﻒ آﺮدﻩ اﻳﻢ آﻪ ﻣﻘـﺪار زﻳـﺮ در ﺁن ﻗـﺮار ﮔﺮﻓﺘـﻪ‬ ‫اﺳﺖ:‬ ‫”‪path =“c:windesktopDotNetExamplesControls‬‬ ‫ﺗﺎﺑﻊ )(‪ Split‬در اﻳﻦ ﺣﺎﻟﺖ ﻣﻲ ﺗﻮاﻧﺪ هﺮ ﻳﻚ اﺟـﺰاي اﻳـﻦ ﻣﻘـﺪار را آـﻪ ﺑـﺎ آـﺎراآﺘﺮ )( از هـﻢ ﺟـﺪا‬ ‫ﺷﺪﻩ اﻧﺪ ﺑﺎ دﺳﺘﻮر زﻳﺮ ﺟﺪا آﺮدﻩ و در ﺧﺎﻧﻪ هﺎي ﻳﻚ ﺁراﻳﻪ ﺑﻪ ﻧﺎم ‪ parts‬ﻗﺮار دهﺪ:‬ ‫)”“,” ‪parts =Split(“c:win desktop DotNet Examples Controls‬‬ ‫ﺣﺎل ﺑﺎ دﺳﺘﻮرات زﻳﺮ ﻣﻲ ﺗﻮاﻧﻴﻢ ﻧﺘﻴﺠﻪ آﺎر را ﻣﺸﺎهﺪﻩ آﻨﻴﻢ:‬ ‫)0(‪For i =0 To parts.GetUpperBound‬‬ ‫))‪Console.WriteLine(parts(i‬‬ ‫‪Next‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٨٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 29.
    ‫)‪:(Data Formatting‬‬ ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ دادﻩ هﺎ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‬ ‫‪ VB.NET‬ﺗﻤـﺎﻣﻲ ﺗـﻮاﺑﻌﻲ آ ـﻪ در 0.6.‪ VB‬ﺑـﺮاي ﻗﺎﻟـﺐ ده ـﻲ ﺑـﻪ دادﻩ هـﺎ ﺑ ـﻪ آـﺎر ﻣـﻲ روﻧ ـﺪ را‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ﭘﺸﺘﻴﺒﺎﻧﻲ ﻣﻲ آﻨﺪ.‬ ‫)]]] ‪Format(expression [,format [,firstdayofweek [,firstweekofyear‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ دﻟﻴﻞ اهﻤﻴﺖ و ﮔﺴﺘﺮﮔﻲ زﻳﺎدي آـﻪ دارد، ﺗـﺎﺑﻌﻲ اﺳـﺖ آـﻪ در اﻳـﻦ آﺘـﺎب، ﺑﻴـﺸﺘﺮﻳﻦ‬ ‫ﺗﻮﺿﻴﺤﺎت در ﻣﻮرد ﺁن دادﻩ ﺷﺪﻩ اﺳﺖ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﻣﻘﺪار را ﺑﺎ ﻓﺮﻣﺖ ﺧﺎﺻﻲ ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺑﻪ ﺑﻴﺎن ﺳﺎدﻩ، اﻳﻦ ﺗﺎﺑﻊ ﺷﻴﻮﻩ ﻧﻤﺎﻳﺶ اﻋﺪاد، رﺷﺘﻪ هـﺎ و ﻣﻘـﺎدﻳﺮ ﺗـﺎرﻳﺦ و زﻣـﺎن را ﻣـﺸﺨﺺ ﻣـﻲ‬ ‫آﻨﺪ.‬ ‫ﺁرﮔﻮﻣـﺎن ‪ ،expression‬ﻣـﻲ ﺗﻮاﻧـﺪ ﻳـﻚ ﻋـﺪد، رﺷـﺘﻪ ﻳـﺎ ﻣﻘـﺪاري از ﻧـﻮع ﺗـﺎرﻳﺦ ﺑﺎﺷـﺪ و ﺁرﮔﻮﻣـﺎن‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫‪ ،Format‬ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي اﺳﺖ آﻪ ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ ﺗﺎﺑﻊ ﻣﺎ ﻣﻘﺪار ﺧﺮوﺟﻲ را ﺑﺎ ﭼﻪ ﻗﺎﻟﺐ ﻳﺎ‬ ‫ﻓﺮﻣﺘﻲ ﺑﺮﮔﺸﺖ و ﻧﻤﺎﻳﺶ دهﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔـﺮ ﻣﻘـﺪار ورودي ﻣـﺎ ﻳﻌﻨـﻲ ﻣﻘـﺪار ﺁرﮔﻮﻣـﺎن ‪ expression‬از ﻧـﻮع زﻣـﺎن )‪(Time‬‬ ‫ﺑﺎﺷﺪ و ﻗﺎﻟﺐ ﺁرﮔﻮﻣﺎن ‪ format‬را ﺑﻪ ﺷﻜﻞ ”‪ “hh:mm:ss‬اﻧﺘﺨﺎب آﺮدﻩ ﺑﺎﺷـﻴﻢ، ﺧﺮوﺟـﻲ ﺗـﺎﺑﻊ،‬ ‫زﻣﺎن ﺣﺎل را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ. ﻣﺜﻼ: ”73:22:81“‬ ‫ﺑـﻪ ﻋﻨـﻮان ﻣﺜـﺎﻟﻲ دﻳﮕـﺮ، ﻓﺮﻣـﺎن زﻳـﺮ ، ﻣﻘـﺪار ‪ pi‬را ﺑـﻪ ﺷـﻜﻞ ﻋـﺪدي اﻋـﺸﺎري ﺑـﺎ دﻗـﺖ ﻣـﻀﺎﻋﻒ‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫)‪ (Double‬ﻣﺤﺎﺳﺒﻪ ﻣﻲ آﻨﺪ.‬ ‫)4*)1(‪Console.WriteLine(Math.Atan‬‬ ‫ﻧﺘﻴﺠﻪ ﺧﺮوﺟﻲ، ﻋﺪد ”97985356295141.3“ ﺧﻮاهﺪ ﺑﻮد.‬ ‫اﻳﻦ ﻧﺘﻴﺠﻪ ي ﺧﻮﺑﻲ اﺳﺖ اﻣﺎ اﮔﺮ ﻗﺮار ﺑﺎﺷﺪ اﻳﻦ ﻋﺪد در ﻳـﻚ ‪ TextBox‬ﻗـﺮار ﺑﮕﻴـﺮد آـﻪ ﺑـﺮاي ﺁن‬ ‫ﻣﺤﺪودﻳﺘﻲ از ﻟﺤﺎظ ﺗﻌﺪاد آﺎراآﺘﺮهﺎي ورودي ﻗﺎﺋﻞ ﺷﺪﻩ اﻳﺪ و اﻳﻦ ﻣﻘﺪار آﻤﺘﺮ از ﺗﻌـﺪاد ارﻗـﺎم اﻳـﻦ‬ ‫ﻋﺪد ﺑﺎﺷﺪ، ﺗﻤﺎﻣﻲ ارﻗﺎم در ‪ TextBox‬ﻗﺮار ﻧﻤﻲ ﮔﻴﺮﻧﺪ ﭘﺲ ﺑﺎﻳﺪ ﺑﺮاي اﻳـﻦ ﻋـﺪد ﻗﺎﻟـﺐ و ﻓﺮﻣﺘـﻲ‬ ‫ﺗﻌﻴﻴﻦ آﺮد. ﭘﺲ از ﺗﺎﺑﻊ )(‪ Format‬ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺘﻔﺎدﻩ ﻣﻲ آﻨﻴﻢ:‬ ‫))”####.##“ ,4*)1(‪Console.WriteLine(Format(Math.Atan‬‬ ‫اﻳﻦ دﺳﺘﻮر ﻧﺘﻴﺠﻪ ﺧﺮوﺟﻲ را ﺑﻪ ﺷﻜﻞ 6141.3 ﻧﻤﺎﻳﺶ ﺧﻮاهﺪ داد.‬ ‫ﻣﺜﺎل دﻳﮕﺮ: ﻓﺮض آﻨﻴﻢ آﻪ ﺷﻤﺎ ﺑﻪ ﻋﻨﻮان ﻳـﻚ ﺣـﺴﺎﺑﺪار در ﻳـﻚ ﺑﺎﻧـﻚ ﻣـﺸﻐﻮل ﺑـﻪ آـﺎر هـﺴﺘﻴﺪ و‬ ‫اﺣﺘﻴﺎج دارﻳﺪ ﺗﺎ در ﻧﺘﻴﺠﻪ ﺣﺴﺎب، ﻳﻚ ﻋﻼﻣﺖ ﺧﺎص ﻣﺜﻼ دﻻر )$( ﻳﺎ رﻳﺎل ﻇﺎهﺮ ﺷﻮد.‬ ‫ﻓﺮض آﻨﻴﺪ آﻪ ﻋﺪد 102543233.454,31 را در ﻧﺘﻴﺠﻪ ي ﻳﻚ ﺣﺴﺎب ﺑﻪ دﺳﺖ ﻣﻲ ﺁورﻳﺪ.‬ ‫ﻣﻲ ﺧﻮاهﻴﻢ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ ،Format‬ﻋﻼﻣﺖ )$( در اﺑﺘﺪاي ﻧﺘﻴﺠﻪ ﻇﺎهﺮ و هﻤﭽﻨـﻴﻦ ﻣﻴـﺰان‬ ‫ﺧﺮدﻩ ي ﭘﻮل ﺑﻪ دﺳﺖ ﺁﻣﺪﻩ ﻓﻘﻂ ﺗﺎ دو رﻗﻢ ﺣﺴﺎب ﺷﻮد. ﭘﺲ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ:‬ ‫102543233.45431= ‪amount‬‬ ‫))”##.###,###$“,‪Console.WriteLine(Format(amount‬‬ ‫ﻧﺘﻴﺠﻪ ﺧﺮوﺟﻲ ﺑﻪ ﺻﻮرت زﻳﺮ ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ:‬ ‫33.454,31$‬ ‫ﺁرﮔﻮﻣﺎن هﺎي ‪ firstdayofweek‬و ‪ ،firstweekofyear‬ﺗﻨﻬﺎ در ﻗﺎﻟﺐ دهﻲ ﺑـﻪ ﻣﻘـﺎدﻳﺮي از ﻧـﻮع‬ ‫ﺗﺎرﻳﺦ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،firstdayofweek‬ﻧﺎم اوﻟﻴﻦ روز هﻔﺘﻪ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ و ﻣﻲ ﺗﻮاﻧﺪ ﻳﻜـﻲ از ﻣﻘـﺎدﻳﺮ‬ ‫زﻳﺮ را ﺑﭙﺬﻳﺮد:‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٩٢‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 30.
    ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪firstdayofweek‬در ﺗﺎﺑﻊ )(‪Format‬‬ ‫ﺗﻮﺿﻴﺤﺎت‬ ‫ﻣﻘﺪار‬ ‫ﻣﻄﺎﺑﻖ ﺑﺎ ﺗﻨﻈﻴﻤﺎت ﺳﻴﺴﺘﻢ‬ ‫0 ﻳﺎ ‪System‬‬ ‫ﻳﻜﺸﻨﺒﻪ )ﻣﻘﺪار ﭘﻴﺶ ﻓﺮض(‬ ‫1 ﻳﺎ ‪Sunday‬‬ ‫دوﺷﻨﺒﻪ‬ ‫2 ﻳﺎ ‪Monday‬‬ ‫ﺳﻪ ﺷﻨﺒﻪ‬ ‫3 ﻳﺎ ‪Tuesday‬‬ ‫ﭼﻬﺎرﺷﻨﺒﻪ‬ ‫4 ﻳﺎ ‪Wednesday‬‬ ‫ﭘﻨﺞ ﺷﻨﺒﻪ‬ ‫5 ﻳﺎ ‪Thursday‬‬ ‫ﺟﻤﻌﻪ‬ ‫6 ﻳﺎ ‪Friday‬‬ ‫ﺷﻨﺒﻪ‬ ‫7 ﻳﺎ ‪Saturday‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،firstweekofyear‬اوﻟﻴﻦ هﻔﺘﻪ از ﺳﺎل را ﻣـﺸﺨﺺ ﻣـﻲ آﻨـﺪ و ﻳﻜـﻲ از ﻣﻘـﺎدﻳﺮ زﻳـﺮ را‬ ‫ﻣﻲ ﭘﺬﻳﺮد:‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ firstweekofyear‬در ﺗﺎﺑﻊ )(‪Format‬‬ ‫ﺗﻮﺿﻴﺤﺎت‬ ‫ﻣﻘﺪار‬ ‫ﻣﻄﺎﺑﻖ ﺑﺎ ﺗﻨﻈﻴﻤﺎت ﺳﻴﺴﺘﻢ.‬ ‫0 ﻳﺎ ‪System‬‬ ‫ﺳﺎل ﺑﺎ هﻔﺘﻪ اول ﻣﺎﻩ ژاﻧﻮﻳﻪ ﺁﻏﺎز ﻣﻲ ﺷﻮد.‬ ‫1 ﻳﺎ 1‪FirstJan‬‬ ‫ﺳﺎل ﺑﺎ هﻔﺘﻪ اي ﺁﻏﺎز ﻣﻲ ﺷـﻮد آـﻪ ﺣـﺪاﻗﻞ ٤‬ ‫2 ﻳﺎ ‪FirstFourDays‬‬ ‫روز ﺁن در ﺳﺎل ﺟﺪﻳﺪ ﺑﺎﺷﺪ.‬ ‫ﺳﺎل ﺑﺎ هﻔﺘﻪ اي ﺁﻏﺎز ﻣـﻲ ﺷـﻮد آـﻪ آـﺎﻣﻼ در‬ ‫3 ﻳﺎ ‪FirstFullWeek‬‬ ‫ﺳﺎل ﺟﺪﻳﺪ ﺑﺎﺷﺪ.‬ ‫ﻗﺎﻟﺐ هـﺎي ﻣﺨﺘﻠﻔـﻲ ﺑـﺮاي ﻧﻤـﺎﻳﺶ ﻣﻘـﺎدﻳﺮ ﻋـﺪدي، رﺷـﺘﻪ اي، ﺗـﺎرﻳﺦ و زﻣـﺎن وﺟـﻮد دارد آـﻪ در‬ ‫ﻟﻴﺴﺖ زﻳﺮ ﺗﻤﺎﻣﻲ ﺁﻧﻬﺎ را ﻣﻲ ﺑﻴﻨﻴﺪ:‬ ‫آﺎراآﺘﺮهﺎﻳﻲ آﻪ ﻣﻲ ﺗﻮان ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ ﺗﺎرﻳﺦ و زﻣﺎن ﺑﻪ آﺎر ﺑﺮد:‬ ‫/ : اﻳﻦ آﺎراآﺘﺮ، ﺟﻬﺖ ﺟﺪا آﺮدن ﺳﺎل، ﻣﺎﻩ و روز از ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ ﺑﻪ آـﺎر ﻣـﻲ رود. اﻟﺒﺘـﻪ‬ ‫در ﺑﻌﻀﻲ ﻣﻜﺎن هﺎ ﻣﻤﻜﻦ اﺳﺖ از آﺎراآﺘﺮهﺎي دﻳﮕﺮي ﺟﻬﺖ اﻳﻦ آﺎر اﺳﺘﻔﺎدﻩ ﺷﻮد.‬ ‫: : اﻳﻦ آﺎراآﺘﺮ، ﺟﻬﺖ ﺟﺪاآﺮدن ﺳﺎﻋﺖ، دﻗﻴﻘﻪ و ﺛﺎﻧﻴﻪ از ﻳﻚ ﻣﻘﺪار از ﻧﻮع زﻣﺎن ﺑـﻪ آـﺎر ﻣـﻲ رود.‬ ‫اﻟﺒﺘﻪ در ﺑﻌﻀﻲ از ﻣﻜﺎن هﺎ ﻣﻤﻜﻦ اﺳﺖ از آﺎراآﺘﺮهﺎي دﻳﮕﺮي ﺟﻬﺖ اﻳﻦ آﺎر اﺳﺘﻔﺎدﻩ ﺷﻮد.‬ ‫‪ : d‬اﻳﻦ آﺎراآﺘﺮ، روز ﻳﻚ ﻣﺎﻩ را ﺑﻪ وﺳﻴﻠﻪ ﻳﻚ ﻋﺪد ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ. اﻳﻦ ﻋﺪد ﻣﻘﺪاري ﺑـﻴﻦ 1 ﺗـﺎ‬ ‫13 اﺳﺖ.‬ ‫‪: dd‬اﻳﻦ آﺎراآﺘﺮ، هﻤﺎﻧﻨﺪ آﺎراآﺘﺮ ‪ d‬رﻓﺘﺎر ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ اﻳﻦ ﺗﺎﺑﻊ، ﻗﺒـﻞ از ارﻗـﺎم ﻳـﻚ ﺗـﺎ‬ ‫ﻧﻪ، ﺻﻔﺮ )0( ﻣﻲ ﮔﺬارد. 10،20،30 و… اﻣﺎ آﺎراآﺘﺮ ‪ ،d‬اﻋﺪاد ﻳﻚ ﺗﺎ ﻧﻪ را ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮل ﻧﺸﺎن‬ ‫ﻣﻲ دهﺪ ﻳﻌﻨﻲ 1،2، 3 و…‬ ‫‪ : ddd‬اﻳﻦ آﺎراآﺘﺮ، ﻧﺎم اﺧﺘﺼﺎري ﻳﻚ روز را ﻧﺸﺎن ﻣﻲ دهﺪ. ﻣﺜﻼ: )‪(Sun-Sat‬‬ ‫‪ : dddd‬اﻳﻦ آﺎراآﺘﺮ، ﻧﺎم آﺎﻣﻞ روز را ﻧﺸﺎن ﻣﻲ دهﺪ. ﻣﺜﻼ: )‪(Sunday-Saturday‬‬ ‫‪ : w‬اﻳــﻦ آــﺎراآﺘﺮ، ﻋــﺪدي را آــﻪ ﻧﻤﺎﻳــﺎﻧﮕﺮ روز هﻔﺘــﻪ اﺳــﺖ ﻧــﺸﺎن ﻣــﻲ دهــﺪ. ﻣــﺜﻼ ﻋــﺪد 1‬ ‫ﺑﺮاي ‪ Sunday‬و 7 ﺑﺮاي ‪Saturday‬‬ ‫‪ : ww‬اﻳﻦ آﺎراآﺘﺮ، ﻋﺪدي را آﻪ ﻧﻤﺎﻳﺎﻧﮕﺮ هﻔﺘﻪ ﺳﺎل اﺳﺖ ﻧﻤﺎﻳﺶ ﻣﻲ دهـﺪ. اﻳـﻦ ﻋـﺪد ﺑـﻴﻦ 1‬ ‫ﺗﺎ 45 اﺳﺖ.‬ ‫‪ : M‬اﻳﻦ آﺎراآﺘﺮ، ﻋﺪدي را آﻪ ﻧﻤﺎﻳﺎﻧﮕﺮ ﻣﺎﻩ ﺳﺎل اﺳﺖ ﻧﺸﺎن ﻣﻲ دهـﺪ. اﮔـﺮ ﺑـﺎ آﺎراآﺘﺮهـﺎي ‪h‬‬ ‫ﻳﺎ ‪ hh‬ﺑﻴﺎﻳﺪ، ﺑﻪ ﺟﺎي ﻧﻤﺎﻳﺶ ﻋﺪد ﻣﺎﻩ، دﻗﻴﻘﻪ را ﻧﺸﺎن ﺧﻮاهﺪ داد.‬ ‫‪ : MM‬اﻳﻦ آﺎراآﺘﺮ هﻤﺎﻧﻨﺪ آﺎراآﺘﺮ ‪ M‬رﻓﺘﺎر ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ اﻳـﻦ ﺗـﺎﺑﻊ ﻗﺒـﻞ از ارﻗـﺎم 0 ﺗـﺎ‬ ‫9، ﺻﻔﺮ )0( ﻣﻲ ﮔﺬارد اﻣﺎ آﺎراآﺘﺮ ‪ ،M‬اﻋﺪاد را ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮل ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫‪ : MMM‬اﻳﻦ آﺎراآﺘﺮ، ﻧﺎم اﺧﺘﺼﺎري ﻳﻚ ﻣﺎﻩ را ﻧﺸﺎن ﻣﻲ دهﺪ. ﻣﺜﻼ: )‪(Jan-Dec‬‬ ‫‪ : MMMM‬اﻳﻦ آﺎراآﺘﺮ، ﻧﺎم آﺎﻣﻞ ﻣﺎﻩ را ﻧﺸﺎن ﻣﻲ دهﺪ. ﻣﺜﻼ: )‪(January-December‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٠٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 31.
    ‫‪: q‬اﻳﻦ آﺎراآﺘﺮ،ﻳﻚ ﭼﻬﺎرم ﻳﻚ ﺳﺎل را ﺑﺎ اﻋﺪادي ﺑﻴﻦ 1 ﺗﺎ 4 ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ. )ﻣﺘﻨﺎﻇﺮ ﻓﺼﻞ(‬ ‫‪ : y‬اﻳﻦ آﺎراآﺘﺮ، ﻋﺪدي را آﻪ ﻧﻤﺎﻳﺎﻧﮕﺮ روز ﺳﺎل اﺳﺖ ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ. )1 ﺗﺎ 663(‬ ‫‪ : yy‬اﻳﻦ آﺎراآﺘﺮ، ﻋﺪدي دو رﻗﻤﻲ را ﻧﺸﺎن ﻣﻲ دهﺪ آﻪ ﻧﻤﺎﻳﺎﻧﮕﺮ ﺳﺎل اﺳﺖ. )00 ﺗﺎ 99(‬ ‫‪ : yyyy‬اﻳﻦ آﺎراآﺘﺮ، ﻋﺪدي 4 رﻗﻤﻲ را ﻧﻤﺎﻳﺶ ﻣﻲ دهـﺪ آـﻪ ﻧﻤﺎﻳـﺎﻧﮕﺮ ﺳـﺎل اﺳـﺖ. )0000 ﺗـﺎ‬ ‫9999(‬ ‫‪ : h‬اﻳﻦ آﺎراآﺘﺮ، ﻋﺪدي را آﻪ ﻧﻤﺎﻳﺎﻧﮕﺮ ﺳﺎﻋﺖ اﺳﺖ ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ. )0 ﺗﺎ 21(‬ ‫‪ : hh‬اﻳﻦ آﺎراآﺘﺮ هﻤﺎﻧﻨﺪ آﺎراآﺘﺮ ‪ h‬رﻓﺘﺎر ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ اﻳﻦ ﺗﺎﺑﻊ ﻗﺒﻞ از ارﻗﺎم 0 ﺗﺎ 21،‬ ‫ﺻﻔﺮ )0( ﻣﻲ ﮔﺬارد اﻣﺎ آﺎراآﺘﺮ ‪ ،h‬اﻋﺪاد را ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮل ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫‪ : H‬اﻳﻦ آﺎراآﺘﺮ، ﺷﻜﻞ آﺎﻣﻠﺘﺮ آﺎراآﺘﺮ ‪ h‬اﺳﺖ و ﺳﺎﻋﺖ را ﺑﻪ ﺻﻮرت 0 ﺗﺎ 42 ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔﺮ ﺳﺎﻋﺖ ﻓﻌﻠﻲ ﺳﻴﺴﺘﻢ 3 ﺑﺎﺷﺪ، 3ﺻﺒﺢ را ﺑﺎ ﻋﺪد 3 و 3 ﺑﻌﺪ از ﻇﻬﺮ را ﺑﺎ ﻋـﺪد‬ ‫51 ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫‪ : HH‬اﻳﻦ آﺎراآﺘﺮ، هﻤﺎﻧﻨﺪ آﺎراآﺘﺮ ‪ H‬رﻓﺘﺎر ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ ﻗﺒـﻞ از ارﻗـﺎم 0 ﺗـﺎ 9، ﺻـﻔﺮ‬ ‫)0( ﻣﻲ ﮔﺬارد. )00 ﺗﺎ 90( وﻟﻲ آﺎراآﺘﺮ ‪ ،H‬ارﻗﺎم 0 ﺗﺎ 9 را ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮل ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫‪:m‬اﻳﻦ آﺎراآﺘﺮ، دﻗﻴﻘﻪ را را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ، ﻣﻨﺘﻬﺎ ﺑﺪون ﮔﺬاﺷﺘﻦ ﻋﺪد ﺻﻔﺮ ﻗﺒـﻞ از ارﻗـﺎم 0 ﺗـﺎ‬ ‫9. ﺑﺎزﻩ ي اﻳﻦ آﺎراآﺘﺮ، ﻋﺪدي ﺑﻴﻦ 0 ﺗﺎ 95 اﺳﺖ.‬ ‫‪ :mm‬هﻤﺎﻧﻨﺪ آﺎراآﺘﺮ ‪ m‬رﻓﺘﺎر آﺮدﻩ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ ﻗﺒﻞ از اﻋﺪاد 0 ﺗﺎ 9، ﺻﻔﺮ )0( ﻣﻲ ﮔﺬارد.‬ ‫‪ :s‬اﻳﻦ آﺎراآﺘﺮ، ﺛﺎﻧﻴﻪ را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ، ﻣﻨﺘﻬﺎ ﺑﺪون ﮔﺬاﺷﺘﻦ ﻋﺪد ﺻـﻔﺮ ﻗﺒـﻞ از ارﻗـﺎم 0 ﺗـﺎ 9.‬ ‫ﺑﺎزﻩ ي اﻳﻦ آﺎراآﺘﺮ ﺑﻴﻦ 0 ﺗﺎ 95 اﺳﺖ.‬ ‫‪ :ss‬هﻤﺎﻧﻨﺪ آﺎراآﺘﺮ ‪ s‬رﻓﺘﺎر آﺮدﻩ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ ﻗﺒﻞ از اﻋﺪاد 0 ﺗﺎ 9، ﺻﻔﺮ )0( ﻣﻲ ﮔﺬارد.‬ ‫‪ : AM/PM‬ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ هﻢ اآﻨﻮن ﻗﺒﻞ از ﻇﻬﺮ اﺳﺖ )‪ (AM‬ﻳﺎ ﺑﻌﺪ از ﻇﻬﺮ )‪(PM‬‬ ‫‪ :am/pm‬هﻤﺎن آﺎراآﺘﺮ ‪ AM/PM‬اﺳﺖ، ﻓﻘﻂ ﻗﺒﻞ ﻳﺎ ﺑﻌﺪ ﺑﻮدن ﻇﻬﺮ را ﺑﺎ ﺣﺮوف آﻮﭼـﻚ ﻧﻤـﺎﻳﺶ‬ ‫ﻣﻲ دهﺪ. )‪(am/pm‬‬ ‫‪ : A/P‬ﻗﺒﻞ ﻳﺎ ﺑﻌﺪ ﺑﻮدن ﻇﻬﺮ را ﺑﺎ ﺣﺮوف اﺧﺘﺼﺎري ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ. ) ‪ A‬ﻳﺎ ‪(P‬‬ ‫‪ : a/p‬هﻤﺎن آﺎراآﺘﺮ ‪ A/P‬اﺳﺖ، ﻓﻘﻂ ﻗﺒﻞ ﻳﺎ ﺑﻌـﺪ ﺑـﻮدن ﻇﻬـﺮ را ﺑـﺎ ﺣـﺮوف آﻮﭼـﻚ ﻧﻤـﺎﻳﺶ ﻣـﻲ‬ ‫دهﺪ.)‪ a‬ﻳﺎ ‪(p‬‬ ‫‪ : AMPM‬اﻳﻦ آﺎراآﺘﺮ ﻧﻴﺰ ﻗﺒﻞ ﻳﺎ ﺑﻌﺪ ﺑﻮدن ﻇﻬﺮ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ اﻣـﺎ ﺑـﻪ ﺟـﺎي اﻳـﻦ آـﺎراآﺘﺮ،‬ ‫آﺎراآﺘﺮي آﻪ ﺑﻪ وﺳﻴﻠﻪ ﺳﻴﺴﺘﻢ ﺗﻌﻴﻴﻦ ﺷﺪﻩ ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ. ﺑﻪ ﻋﻨﻮان ﻣﺜـﺎل در وﻳﻨـﺪوز هـﺎي‬ ‫ﻓﺎرﺳﻲ ﺑﺎ آﻠﻤﺎت “ﺻﺒﺢ” و “ﻋﺼﺮ” ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﺑــﺮاي ﺗﻐﻴﻴــﺮ ﻧﺤــﻮﻩ ﻧﻤــﺎﻳﺶ، ﺑــﻪ ﺳــﺮﺑﺮگ ‪ Regional Options‬از ﻗــﺴﻤﺖ ‪Regional and‬‬ ‫‪ Language Options‬در ‪ Control Panel‬ﻣﺮاﺟﻌﻪ آﻨﻴﺪ.‬ ‫آﺎراآﺘﺮهﺎﻳﻲ آﻪ ﻣﻲ ﺗﻮان ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ ﻣﻘﺎدﻳﺮ ﻋﺪدي ﺑﻪ آﺎر ﺑﺮد، ٦١ آـﺎراآﺘﺮ هـﺴﺘﻨﺪ آـﻪ‬ ‫ﻧﺤﻮﻩ ي آﺎر ﺑﺎ ﺁﻧﻬﺎ ﺑﺮ ﻋﻬﺪﻩ ي ﺧﻮاﻧﻨﺪﮔﺎن ﻋﺰﻳﺰ اﺳﺖ.‬ ‫] ‪FormatCurrency(expression [,numDigitsAfterDecimal‬‬ ‫)] ‪[,includeLeadingDigit ][,useParensForNegativeNumbers ][,groupDigits‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻣﻘﺪار ﻋﺪدي را ﺑﻪ ﺷﻜﻞ ﻳﻚ ﻣﻘﺪار ارزي )‪ (Currency‬ﻗﺎﻟﺐ ﺑﻨـﺪي ﺷـﺪﻩ هﻤـﺮاﻩ ﺑـﺎ‬ ‫ﻧﻤﺎدي آﻪ در ﺳﺮﺑﺮگ ‪ Regional Options‬از ﻗﺴﻤﺖ ‪Regional and Language Options‬‬ ‫از ‪ Control Panel‬ﻣﺸﺨﺺ ﺷﺪﻩ اﺳﺖ، ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺑ ـﻪ ﻋﻨ ـﻮان ﻣﺜ ـﺎل در وﻳﻨ ـﺪوزهﺎي ﻓﺎرﺳ ـﻲ، ﻧﻤ ـﺎد ﻣﻘ ـﺎدﻳﺮ ارزي ﺑ ـﺎ آﻠﻤ ـﻪ “رﻳ ـﺎل” و در وﻳﻨ ـﺪوزهﺎي‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫اﻧﮕﻠﻴﺴﻲ ﺑﺎ آﺎراآﺘﺮ ”$“، ﻣﺸﺨﺺ ﻣﻲ ﺷﻮد.‬ ‫ﺑﺮاي ﺗﻐﻴﻴﺮ ﻧﺤﻮﻩ ﻧﻤﺎﻳﺶ اﻳﻦ ﻣﻘﺎدﻳﺮ، ﺑﻪ ﻗﺴﻤﺖ ﮔﻔﺘﻪ ﺷﺪﻩ در ﺑﺎﻻ ﻣﺮاﺟﻌﻪ آﻨﻴﺪ.‬ ‫در اﻳﻦ ﺗﺎﺑﻊ، ﺗﻤﺎﻣﻲ ﺁرﮔﻮﻣﺎن هﺎ ﺑﻪ ﺟﺰ اوﻟﻴﻦ ﺁرﮔﻮﻣﺎن، اﺧﺘﻴﺎري هﺴﺘﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻣﻘﺪاري ﻋﺪدي اﺳﺖ آﻪ ﻗﺼﺪ ﺑﺮﮔﺸﺖ ﺁن ﺑﺎ ﻓﺮﻣﺖ ‪ Currency‬را دارﻳﻢ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،numDigitsAfterDecimal‬ﻣﻘﺪاري ﻋﺪدي اﺳﺖ آﻪ ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ ﭼﻨﺪ ﻋـﺪد در‬ ‫ﺳﻤﺖ راﺳـﺖ ﺑﻌـﺪ از اﻋـﺸﺎر ﺑﺎﻳـﺪ ﻗـﺮار ﺑﮕﻴﺮﻧـﺪ. ﻣﻘـﺪار ﭘـﻴﺶ ﻓـﺮض، 1- اﺳـﺖ ﻳﻌﻨـﻲ ﺗﻨﻈﻴﻤـﺎت‬ ‫‪ Regional and Language Options‬را ﺑﻪ آﺎر ﻣﻲ ﺑﺮد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،includeLeadingDigit‬ﻳﻚ ﻣﻘﺪار ﺛﺎﺑـﺖ ‪ Tristate‬اﺳـﺖ. )ﺛﺎﺑـﺖ ‪ ،Tristate‬ﻣﻘـﺪاري‬ ‫اﺳـﺖ آـﻪ ﻣـﻲ ﺗﻮاﻧـﺪ ‪ False ،True‬ﻳـﺎ ‪ UseDefault‬ﺑﺎﺷـﺪ( و ﻣـﺸﺨﺺ ﻣـﻲ آﻨـﺪ آـﻪ ﺁﻳـﺎ اﮔـﺮ‬ ‫ـ ـ ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫ﻣﻘﺪاري اﻋﺸﺎري آﻤﺘﺮ از 1 ﺑﻮد، در ﺳﻤﺖ ﭼﭗ اﻋﺸﺎر، ﻋﺪد ﺻﻔﺮ ﻗﺮار ﮔﻴﺮد ﻳﺎ ﺧﻴﺮ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻋﺪد هﻔﺖ دهﻢ آﻪ ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ ﺷﻜﻞ ”7.0“ و ﻳﺎ ”7.“ ﻧﻤﺎﻳﺶ دادﻩ ﺷﻮد.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫١٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 32.
    ‫ﺁرﮔﻮﻣــﺎن ‪ ،useParensForNegativeNumbers‬ﻧﻴــﺰﻳــﻚ ﻣﻘــﺪار ﺛﺎﺑــﺖ ‪ Tristate‬اﺳــﺖ آــﻪ‬ ‫ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ ﺁﻳﺎ اﻋﺪاد ﻣﺜﺒﺖ را ﺑﺎ دو ﭘﺮاﻧﺘﺰ در دو ﻃﺮف ﺁﻧﻬﺎ ﺑﺮﮔﺸﺖ دهﺪ ﻳﺎ ﺧﻴﺮ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ groupDigits‬هﻢ ﻳﻚ ﻣﻘﺪار ﺛﺎﺑﺖ ‪ Tristate‬اﺳﺖ و ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ ﺁﻳـﺎ اﻋـﺪاد ﺑـﻴﺶ‬ ‫از 5 رﻗﻤﻲ ﺑﺎ آﺎراآﺘﺮي آﻪ در ﻗـﺴﻤﺖ ‪ Regional and Language Options‬ﻣـﺸﺨﺺ ﺷـﺪﻩ‬ ‫از ﻳﻜﺪﻳﮕﺮ ﺟﺪا ﺷﻮﻧﺪ ﻳﺎ ﺧﻴﺮ. ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل در ﺻﻮرت ‪ True‬ﺑﻮدن اﻳـﻦ ﺁرﮔﻮﻣـﺎن، ﻋـﺪد 654,432‬ ‫ﺑﻪ ﻃﺮﻳﻘﻲ آﻪ ﻣﺸﺎهﺪﻩ ﻣﻲ آﻨﻴﺪ ﺑﺎ آﺎراآﺘﺮ ),( از ﻳﻜﺪﻳﮕﺮ ﺟـﺪا ﺷـﺪﻩ و اﻋـﺪاد از ﺳـﻤﺖ راﺳـﺖ،‬ ‫ﺳﻪ ﺗﺎ ﺳﻪ ﺗﺎ ﺟﺪا ﻣﻲ ﺷﻮﻧﺪ. در ﺻﻮرت ‪ False‬ﺑﻮدن اﻳﻦ ﺁرﮔﻮﻣﺎن، اﻋﺪاد ﭘﺸﺖ ﺳﺮ هـﻢ و ﺑـﺪون‬ ‫آﺎراآﺘﺮ ﺟﺪاآﻨﻨﺪﻩ ﻇﺎهﺮ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫)] ‪FormatDateTime(date [,namedFormat‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ )‪ (Date‬ﻳﺎ زﻣﺎن )‪ (Time‬را ﻗﺎﻟﺐ ﺑﻨﺪي ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،date‬ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ ﻳﺎ زﻣﺎن اﺳﺖ آﻪ ﺑﺎﻳﺪ ﻗﺎﻟﺐ ﺑﻨﺪي ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،namedFormat‬ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ ﭼﻪ ﻧﻮع ﻗﺎﻟﺐ ﺑﻨﺪي ﺑﺎﻳﺪ ﺑﺮاي ﺗﺎرﻳﺦ ﻳـﺎ‬ ‫زﻣﺎن ﺑﻪ آﺎر رود.‬ ‫اﻳﻦ ﺁرﮔﻮﻣﺎن ﻣﻲ ﺗﻮاﻧﺪ ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ زﻳﺮ را ﺑﭙﺬﻳﺮد:‬ ‫‪ :GeneralDate‬اﮔﺮ در ﺁرﮔﻮﻣﺎن ‪ ،date‬ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ ﺁﻣﺪﻩ ﺑﺎﺷﺪ، ﺗﺎرﻳﺦ ﺑﻪ ﺷﻜﻞ آﻮﺗﺎﻩ‬ ‫ﻣﺜﻼ ”4002/20/41“ﻧﻤﺎﻳﺶ دادﻩ ﺧﻮاهﺪ ﺷﺪ و اﮔﺮ ﻣﻘﺪار از ﻧﻮع زﻣـﺎن ﺑﺎﺷـﺪ، زﻣـﺎن ﺑـﻪ ﺷـﻜﻞ‬ ‫آﺎﻣﻞ ﻣﺜﻼ “ﻋﺼﺮ 55:74:60“ ﻧﻤﺎﻳﺶ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﺗﻮﺟﻪ: اﮔﺮ هﺮ دو ﻣﻘﺪار ﺗﺎرﻳﺦ و زﻣﺎن ﺑﻪ آﺎر روﻧﺪ، ﭘﺸﺖ ﺳﺮ هﻢ ﻧﻤﺎﻳﺶ دادﻩ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫‪ :LongDate‬اﻳﻦ ﻣﻘﺪار ﺛﺎﺑﺖ، ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗـﺎرﻳﺦ را ﺑـﻪ ﺻـﻮرت ﻃـﻮﻻﻧﻲ ﻧﻤـﺎﻳﺶ و ﺑﺮﮔـﺸﺖ‬ ‫ﻣﻲ دهﺪ. ﻣﺜﻼ: “ﺷﻨﺒﻪ, ٤١ ﺁﺑﺎن, ٢٨٣١ ”‬ ‫‪ :ShortDate‬اﻳﻦ ﻣﻘﺪار ﺛﺎﺑﺖ، ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ را ﺑﻪ ﺻﻮرت آﻮﺗﺎﻩ ﻧﻤﺎﻳﺶ و ﺑﺮﮔـﺸﺖ ﻣـﻲ‬ ‫دهﺪ. ﻣﺜﻼ: “٤١/٢٠/٤٠٠٢”‬ ‫‪ :LongTime‬اﻳﻦ ﻣﻘﺪار ﺛﺎﺑﺖ، ﻳﻚ ﻣﻘﺪار از ﻧﻮع زﻣﺎن را ﺑـﻪ ﺻـﻮرت ﻃـﻮﻻﻧﻲ ﻧﻤـﺎﻳﺶ ﻣـﻲ دهـﺪ.‬ ‫ﻣﺜﻼ: “٤٣:٨٥:٦٠ ﻋﺼﺮ”‬ ‫‪ :ShortTime‬اﻳﻦ ﻣﻘﺪار ﺛﺎﺑﺖ، ﻳﻚ ﻣﻘﺪار از ﻧﻮع زﻣﺎن را ﺑﻪ ﺻﻮرت آﻮﺗﺎﻩ ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﻣﺜﻼ: “٣٢:٩١”‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: ﺗﻤـﺎﻣﻲ ﻣﻘـﺎدﻳﺮ ﺛﺎﺑـﺖ ﺑـﺎﻻ، ﺑـﺮ اﺳـﺎس ﺗﻨﻈﻴﻤـﺎﺗﻲ آـﻪ در ﻗـﺴﻤﺖ ‪Regional and‬‬ ‫‪ Language Options‬از ‪ Control Panel‬ﺻﻮرت ﮔﺮﻓﺘﻪ اﺳﺖ ﻋﻤﻞ ﻣﻲ آﻨﻨﺪ.‬ ‫] ‪FormatNumber(expression [,numDigitsAfterDecimal‬‬ ‫)] ‪[,includeLeadingDigit ][,useParensForNegativeNumbers ][,groupDigits‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻣﻘﺪار ﻋﺪدي را ﺑﺎ ﻗﺎﻟﺐ ﺑﻨﺪي دﻳﮕﺮي ﺑﻪ ﺻﻮرت ﻋﺪدي ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺗﻤﺎﻣﻲ ﺁرﮔﻮﻣﺎن هﺎي اﻳﻦ ﺗﺎﺑﻊ در ﺗﻮﺿﻴﺤﺎت ﺗﺎﺑﻊ )(‪ FormatCurrency‬ﺑﻴﺎن ﺷﺪﻧﺪ.‬ ‫] ‪FormatPercent(expression [,numDigitsAfterDecimal‬‬ ‫)] ‪[,includeLeadingDigit ][,useParensForNegativeNumbers ][,groupDigits‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻋﺪد را ﺑﺮ ﺣﺴﺐ درﺻﺪ ﺑﺮﮔﺸﺖ ﻣـﻲ دهـﺪ ﻳﻌﻨـﻲ ﻋـﺪد را در ٠٠١ ﺿـﺮب آـﺮدﻩ و ﺑـﺎ‬ ‫ﻧﻤﺎد درﺻﺪ )%( و ﺑﺎ ﻗﺎﻟﺒﻲ آﻪ ﻣﺸﺨﺺ ﺷﺪﻩ اﺳﺖ ﺑﺮﮔﺸﺖ و ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﺗﻤﺎﻣﻲ ﺁرﮔﻮﻣﺎن هﺎي اﻳﻦ ﺗﺎﺑﻊ در ﺗﻮﺿﻴﺤﺎت ﺗﺎﺑﻊ )(‪ FormatCurrency‬ﺑﻴﺎن ﺷﺪﻧﺪ.‬ ‫)‪LSet(string,len) , RSet(string,len‬‬ ‫اﻳﻦ ﺗﻮاﺑﻊ، ﺑـﻪ ﺗﻌـﺪادي آـﻪ ﻣـﺸﺨﺺ ﻣـﻲ ﺷـﻮد، در ﺳـﻤﺖ ﭼـﭗ )‪ (Lset‬ﻳـﺎ راﺳـﺖ )‪ (Rset‬ﻳـﻚ‬ ‫ﻋﺒﺎرت، ﻓﻀﺎي ﺧﺎﻟﻲ ﻗﺮار ﻣﻲ دهﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ string‬آﻪ ﻣﻲ ﺗﻮاﻧﺪ از هﺮ ﻧﻮع ﻣﻘﺪاري ﺑﺎﺷﺪ، رﺷﺘﻪ اي را ﻣﺸﺨﺺ ﻣﻲ آﻨـﺪ آـﻪ ﺑﺎﻳـﺪ‬ ‫در ﺳﻤﺖ ﭼﭗ ﻳﺎ راﺳﺖ ﺁن، ﻓﻀﺎي ﺧﺎﻟﻲ اﺿﺎﻓﻪ ﺷﻮد.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٢٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 33.
    ‫ﺁرﮔﻮﻣﺎن ‪ len‬ﻧﻴﺰﻣﻘﺪاري ﻋﺪدي اﺳﺖ آﻪ ﺗﻌﺪاد ﻓﻀﺎي ﺧﺎﻟﻲ را آﻪ ﺑﺎﻳﺪ اﻳﺠﺎد ﺷﻮد ﻣﺸﺨﺺ ﻣﻲ‬ ‫آﻨﺪ.‬ ‫ﻣﺜﺎل هﺎي زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)”]“ & )02,”‪Console.WriteLine(“[“ & RSet(“Behrouz‬‬ ‫)”]“ & )02,”‪Console.WriteLine(“[“ & LSet(“Rad‬‬ ‫))01,65.43(‪Console.WriteLine(RSet‬‬ ‫))01,99.6534(‪Console.WriteLine(RSet‬‬ ‫))01,10.4(‪Console.WriteLine(RSet‬‬ ‫ﺧﺮوﺟﻲ ﭘﺲ از اﺟﺮا ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺧﻮاهﺪ ﺷﺪ:‬ ‫[‬ ‫]‪Behrouz‬‬ ‫‪[Rad‬‬ ‫]‬ ‫65.43‬ ‫99.6534‬ ‫10.4‬ ‫)‪Val(string) , Str(number‬‬ ‫ﺗﺎﺑﻊ )(‪ ،Val‬ﻳـﻚ ﻣﻘـﺪار رﺷـﺘﻪ اي را ﺑـﻪ ﻋﻨـﻮان ورودي درﻳﺎﻓـﺖ آـﺮدﻩ و ﺁن را ﺑـﻪ ﺻـﻮرت ﻣﻘـﺪاري‬ ‫ﻋﺪدي ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ Str‬دﻗﻴﻘﺎ ﻋﻜﺲ ﺗـﺎﺑﻊ )(‪ Val‬رﻓﺘـﺎر آـﺮدﻩ و ﻳـﻚ ﻣﻘـﺪار ﻋـﺪدي را درﻳﺎﻓـﺖ آـﺮدﻩ و ﺁن را ﺑـﻪ‬ ‫ﺻﻮرت ﻣﻘﺪاري ﻋﺪدي ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﻣﻜﺎﻧﻴﺰم آﺎر ﺗﺎﺑﻊ )(‪ Val‬ﺑﻪ اﻳﻦ ﺷﻜﻞ اﺳﺖ آﻪ از اﺑﺘﺪاي رﺷﺘﻪ ورودي ﺷﺮوع ﺑﻪ ﺧﻮاﻧـﺪن ﺁن ﻣـﻲ‬ ‫آﻨﺪ و زﻣﺎﻧﻲ آﻪ ﺑﻪ آﺎراآﺘﺮي ﻏﻴـﺮ ﻋـﺪدي رﺳـﻴﺪ ﺟـﺴﺘﺠﻮ ﻣﺘﻮﻗـﻒ و ﻧﺘﻴﺠـﻪ ﺑﺮﮔـﺸﺖ دادﻩ ﻣـﻲ‬ ‫ﺷﻮد.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫” 50.6:81“= ‪Dim a As String‬‬ ‫))‪Console.WriteLine(Val(a‬‬ ‫آﺎراآﺘﺮي ﻏﻴﺮ ﻋﺪدي اﺳﺖ.‬ ‫آﺎراآﺘﺮ ”:“‬ ‫ﻧﺘﻴﺠﻪ ي ﺧﺮوﺟﻲ، ﻋﺪد 81 ﺧﻮاهﺪ ﺑﻮد زﻳﺮا‬ ‫ﻣﺜﺎﻟﻲ ﺑﺮاي ﺗﺎﺑﻊ )(‪:Str‬‬ ‫81 = ‪Dim a As Integer‬‬ ‫))‪Console.WriteLine(Str(a‬‬ ‫ﻧﺘﻴﺠﻪ ﺧﺮوﺟﻲ، رﺷﺘﻪ ”81“ ﺧﻮاهﺪ ﺑﻮد.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٣٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 34.
    ‫)‪:(Math‬‬ ‫ﺗﻮاﺑﻊ رﻳﺎﺿﻲ‬ ‫در ‪ VB.NET‬ﺗﻤﺎﻣﻲ ﺗﻮاﺑﻊ رﻳﺎﺿﻲ 0.6.‪ VB‬ﺑﻪ ﻋﻨﻮان ﻣﺘﺪهﺎﻳﻲ در آـﻼس ‪ Math‬ﻗـﺮار دادﻩ ﺷـﺪﻩ‬ ‫اﻧﺪ. ﭘﺲ در اﻳﻦ ﺑﺨﺶ ﺁﻧﻬﺎ را ﺑﺎ ﻧﺎم ﻣﺘﺪ ﺻﺪا ﻣﻲ زﻧﻴﻢ.‬ ‫ﺑﺮاي اﺳﺘﻔﺎدﻩ از ﻣﺘﺪهﺎي رﻳﺎﺿﻲ در ‪ VB.NET‬ﺑﺎﻳﺪ آﻼس ‪ Math‬را ﺑﻪ ﺑﺮﻧﺎﻣـﻪ ي ﺧـﻮد اﺿـﺎﻓﻪ ﻳـﺎ‬ ‫ﻗﺒﻞ از اﺳـﺘﻔﺎدﻩ از اﻳـﻦ ﻣﺘـﺪهﺎ، آﻠﻤـﻪ ‪ Math‬را ﻗﺒـﻞ از ﻧـﺎم ﻣﺘـﺪ ذآـﺮ آﻨﻴـﺪ ﻣﺜـﻞ: )‪،Math.Abs‬‬ ‫‪(Math.Cos‬‬ ‫)‪Abs(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ، ﻗﺪر ﻣﻄﻠﻖ ﻳﻚ ﻋﺒﺎرت ﻋﺪدي را ﻣﺤﺎﺳﺒﻪ ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻋﺪدي اﺳﺖ آﻪ ﺑﺎﻳﺪ ﻗﺪر ﻣﻄﻠـﻖ ﺁن ﻣﺤﺎﺳـﺒﻪ ﮔـﺮدد. اﮔـﺮ ‪expression‬‬ ‫ﺑﺰرﮔﺘﺮ ﻳﺎ ﻣﺴﺎوي ﺻﻔﺮ ﺑﺎﺷﺪ، ﻧﺘﻴﺠﻪ ي ﻣﺘﺪ هﻤﺎن ﻋﺒﺎرت ‪ expression‬ﺧﻮاهﺪ ﺑﻮد وﮔﺮﻧﻪ ﻋﺒـﺎرت‬ ‫‪ expression‬در ﻋﺪد 1– ﺿﺮب ﺷﺪﻩ و ﻧﺘﻴﺠﻪ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)10.1(‪Abs‬‬ ‫)10.1-(‪Abs‬‬ ‫ﻧﺘﻴﺠﻪ هﺮ دو اﻳﻦ دﺳﺘﻮرات، ﻋﺪد 10.1 ﺧﻮاهﺪ ﺑﻮد.‬ ‫)‪Atan(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ، ﺁرك ﺗﺎﻧﮋاﻧﺖ ﻳﻚ ﻣﻘﺪار را ﻣﺤﺎﺳﺒﻪ و ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ expression‬ﻣﻘﺪاري اﺳﺖ آﻪ ﺁرك ﺗﺎﻧﮋاﻧـﺖ ﺁن ﺑﺎﻳـﺪ ﻣﺤﺎﺳـﺒﻪ ﮔـﺮدد. ﻧﺘﻴﺠـﻪ اﻳـﻦ ﻣﺘـﺪ،‬ ‫ﻣﻘﺪاري ﺑﻴﻦ 97075.1– ﺗﺎ 97075.1 اﺳﺖ.‬ ‫ﻣﺜﺎل:‬ ‫61.1=)3.2(‪Atan‬‬ ‫)‪Cos(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ، آﺴﻴﻨﻮس ﻳﻚ زاوﻳﻪ را ﺑﺮ ﺣﺴﺐ رادﻳﺎن ﻣﺤﺎﺳﺒﻪ ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻋﺒﺎرﺗﻲ اﺳﺖ آﻪ ﺑﺎﻳﺪ آﺴﻴﻨﻮس ﺁن ﻣﺤﺎﺳﺒﻪ ﺷﻮد. ﺣﺎﺻـﻞ ﻣﺘـﺪ )(‪،Cos‬‬ ‫ﻣﻘﺪاري ﺑﻴﻦ 1– ﺗﺎ 1 اﺳﺖ.‬ ‫ﻣﺜﺎل:‬ ‫1=)0(‪Cos‬‬ ‫76.0-=)3.2(‪Cos‬‬ ‫)‪Exp(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ، ﺗﻮاﻧﻲ از ‪) e‬ﻋﺪد ﻧﭙﺮ( را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻧﻜﺘﻪ: ﺗﻘﺮﻳﺒﺎ 2817.2=‪e‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻣﻘﺪاري ﻋﺪدي)ﺗﻮاﻧﻲ( اﺳﺖ آﻪ ﺑﺎﻳﺪ ﻋﺪد ﻧﭙـﺮ ﺁن ﻣﺤﺎﺳـﺒﻪ ﮔـﺮدد و ﻣـﻲ‬ ‫ﺗﻮاﻧﺪ ﻳﻚ ﻋﺪد ﺻﺤﻴﺢ، اﻋﺸﺎري، ﻣﺜﺒﺖ ﻳﺎ ﻣﻨﻔﻲ ﺑﺎﺷﺪ.‬ ‫ﻣﺜﺎل:‬ ‫13.7=)2(‪Exp‬‬ ‫)‪Int(expression) , Fix(expression‬‬ ‫هﺮ دو اﻳﻦ ﻣﺘﺪهﺎ، ﻣﻘﺪاري ﻋﺪدي را درﻳﺎﻓﺖ آﺮدﻩ و ﻋﺪدي از ﻧﻮع ‪) Integer‬ﺻـﺤﻴﺢ( را ﺑﺮﮔـﺸﺖ‬ ‫ﻣﻲ دهﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ expression‬ﻋﺒﺎرﺗﻲ ﻋﺪدي اﺳﺖ آﻪ ﺑﻪ ﻋﻨﻮان ورودي اﻳﻦ ﻣﺘﺪهﺎ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٤٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 35.
    ‫اﮔﺮ ﻣﻘﺪار ورودي،ﺻﺤﻴﺢ و ﻣﺜﺒﺖ ﻳﺎ ﻣﻨﻔﻲ ﺑﺎﺷﺪ، هﻤﺎن ﻣﻘﺪار ‪ expression‬ﺑﺮﮔـﺸﺖ دادﻩ ﻣـﻲ‬ ‫ﺷﻮد.‬ ‫اﮔﺮ ﻣﻘـﺪار ورودي، اﻋـﺸﺎري و ﻣﺜﺒـﺖ ﺑﺎﺷـﺪ، ﻗـﺴﻤﺖ اﻋـﺸﺎري ﺣـﺬف ﺷـﺪﻩ و ﻗـﺴﻤﺖ ﺻـﺤﻴﺢ‬ ‫ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫اﮔﺮ ﻣﻘﺪار ورودي، اﻋﺸﺎري و ﻣﻨﻔﻲ ﺑﺎﺷﺪ دو ﺣﺎﻟﺖ دارد:‬ ‫در ﺣﺎﻟﺖ اول اﮔﺮ از ﻣﺘـﺪ )(‪ Int‬اﺳـﺘﻔﺎدﻩ ﺷـﻮد، اوﻟـﻴﻦ ﻋـﺪد ﺻـﺤﻴﺢ ﻣﻨﻔـﻲ آـﻮﭼﻜﺘﺮ ﻳـﺎ ﻣـﺴﺎوي‬ ‫ﻋﺒﺎرت ورودي ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫در دوﻣﻴﻦ ﺣﺎﻟﺖ اﮔﺮ از ﻣﺘﺪ )(‪ Fix‬اﺳﺘﻔﺎدﻩ ﺷـﻮد، اوﻟـﻴﻦ ﻋـﺪد ﺻـﺤﻴﺢ ﻣﻨﻔـﻲ ﺑﺰرﮔﺘـﺮ ﻳـﺎ ﻣـﺴﺎوي‬ ‫ﻋﺒﺎرت ورودي ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﻣﺜﺎل هﺎي زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫21=)21(‪Int‬‬ ‫6=)6(‪Fix‬‬ ‫41=)32.41(‪Int‬‬ ‫052=)))5.2(‪Int(500/Int‬‬ ‫51=)5.51(‪Fix‬‬ ‫3-=)3.2-(‪Int‬‬ ‫2-=)3.2-(‪Fix‬‬ ‫ﭘﻴﺸﻨﻬﺎد ﻣﻲ آﻨﻢ اﮔﺮ ﻣﻲ ﺧﻮاهﻴﺪ آﻪ از دﺳﺖ ﻗﺴﻤﺖ اﻋﺸﺎري ﻳﻚ ﻋﺪد ﺧـﻼص ﺷـﻮﻳﺪ و ﺁن را‬ ‫اﺻﻄﻼﺣﺎ ﮔﺮد آﻨﻴﺪ، ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ آﻨﻴﺪ:‬ ‫)5.0+ ‪Int(value‬‬ ‫‪ ،Value‬ﻣﻘﺪاري ﻋﺪدي اﺳﺖ آﻪ ﻗﺼﺪ ﮔﺮد آﺮدن ﺁن را دارﻳﺪ.‬ ‫اﻳﻦ دﺳﺘﻮر، ﻓﺮﻣﺎن ﺑﺴﻴﺎر آﺎرﺁﻣﺪي ﺑﺮاي ﮔﺮدآﺮدن هﺮ ﻧـﻮع ﻣﻘـﺪاري ﻋـﺪدي اﺳـﺖ ﺑـﺎ اﻳـﻦ وﺟـﻮد،‬ ‫ﻣﺘﺪ )(‪ Round‬آﻪ در ﻗﺴﻤﺖ ﺑﻌﺪ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻩ اﺳﺖ ﺑﻪ ﺷﻴﻮﻩ اي ﺁﺳﺎﻧﺘﺮ، ﺑﻬﺘـﺮ و آﺎرﺁﻣـﺪﺗﺮ‬ ‫اﻳﻦ آﺎر را اﻧﺠﺎم ﻣﻲ دهﺪ.‬ ‫)] ‪Round(expression [,numdecimalplaces‬‬ ‫اﻳﻦ ﻣﺘﺪ، ﻳﻚ ﻋﺪد اﻋﺸﺎري را ﮔﺮد ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻣﻘﺪاري اﺳﺖ آﻪ ﺑﺎﻳﺪ ﮔﺮد ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ numdecimalplaces‬ﻣﺸﺨﺺ ﻣﻲ آﻨـﺪ آـﻪ اﻳـﻦ ﻣﻘـﺪار ﺗـﺎ ﭼﻨـﺪ رﻗـﻢ ﺑﻌـﺪ از‬ ‫اﻋــﺸﺎر ﺑﺎﻳــﺪ ﮔــﺮد ﺷــﻮد. اﮔــﺮ از ذآــﺮ اﻳــﻦ ﺁرﮔﻮﻣــﺎن ﺧــﻮدداري ﺷــﻮد، ﻳــﻚ ﻣﻘــﺪار از ﻧــﻮع ﺻــﺤﻴﺢ‬ ‫)‪ (Integer‬ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﻣﺜﺎل هﺎي زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫3=)94.3(‪Round‬‬ ‫4=)15.3(‪Round‬‬ ‫5.3=)1,94.3(‪Round‬‬ ‫5.3=)1,15.3(‪Round‬‬ ‫)‪Log(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ، ﻟﮕـﺎرﻳﺘﻢ ﻃﺒﻴﻌـﻲ )ﻳـﺎ ﻟﮕـﺎرﻳﺘﻢ ﭘﺎﻳـﻪ ‪ e‬آـﻪ ﺗﻘﺮﻳﺒـﺎ 2817.2=‪ e‬اﺳـﺖ( ﻣﻘـﺪاري را ﺑﺮﻣـﻲ‬ ‫ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻣﻘﺪاري ﻋﺪدي اﺳﺖ آﻪ ﻟﮕﺎرﻳﺘﻢ ﻃﺒﻴﻌﻲ ﺁن ﺑﺎﻳﺪ ﻣﺤﺎﺳـﺒﻪ ﺷـﻮد و ﺣﺘﻤـﺎ‬ ‫ﺑﺎﻳﺪ ﻣﻘﺪاري ﻣﺜﺒﺖ ﺑﺎﺷﺪ.‬ ‫ﻋﺒﺎرت ))‪ Log(Exp(N‬و ))‪ Exp(Log(N‬هﺮ دو ﻋﺪد ‪ N‬را ﺑﺮﻣﻲ ﮔﺮداﻧﻨﺪ.‬ ‫ﻟﮕﺎرﻳﺘﻢ ﻃﺒﻴﻌﻲ، ﻟﮕﺎرﻳﺘﻢ ﭘﺎﻳﻪ ﻋﺪد ‪) e‬ﻧﭙﺮ( اﺳﺖ.‬ ‫ﻣﻘﺪار دﻗﻴﻖ ﻋﺪد ﻧﭙﺮ را ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺎ دﺳﺘﻮر )1(‪ Exp‬ﺑﻪ دﺳﺖ ﺑﻴﺎورﻳﺪ.‬ ‫ﺑﺮاي ﻣﺤﺎﺳﺒﻪ ﻟﮕﺎرﻳﺘﻢ هﺎ در ﭘﺎﻳﻪ هـﺎي دﻳﮕـﺮ، ﻋـﺪد ﻟﮕـﺎرﻳﺘﻢ ﻃﺒﻴﻌـﻲ را ﺑـﺮ ﻟﮕـﺎرﻳﺘﻢ ﭘﺎﻳـﻪ ﺗﻘـﺴﻴﻢ‬ ‫آﻨﻴﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل، دﺳﺘﻮر زﻳﺮ ﻟﮕﺎرﻳﺘﻢ ﻳﻚ ﻋﺪد در ﭘﺎﻳﻪ ي 01 را ﻣﺤﺎﺳﺒﻪ ﻣﻲ آﻨﺪ.‬ ‫)01(‪Log10 =Log(number)/Log‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٥٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 36.
    ‫)‪Hex(expression) , Oct(expression‬‬ ‫اﻳـﻦﻣﺘـﺪهﺎ ﻋـﺪدي را ﺑـﻪ ﻋﻨـﻮان ورودي درﻳﺎﻓـﺖ آـﺮدﻩ و ﺁن را ﺑـﻪ ﻣﺒﻨـﺎي ٨ )‪ (Oct‬ﻳـﺎ ﻣﺒﻨـﺎي ٦١‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫)‪ (Hex‬ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﻨﺪ و ﺑﻪ ﺻﻮرت ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي )‪ (String‬ﺑﺮﮔﺸﺖ ﻣﻲ دهﻨﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻋﺒﺎرت )74(‪ ،Hex‬ﻣﻘﺪار ”‪ “2F‬و ﻋﺒـﺎرت )74(‪ Oct‬ﻣﻘـﺪار ”75“ را ﺑﺮﮔـﺸﺖ ﻣـﻲ‬ ‫دهﻨﺪ.‬ ‫ﺑﺮاي ﺗﻌﻴﻴﻦ آﺮدن اﻋﺪاد در ﻣﺒﻨﺎي ٦١، اﺑﺘﺪاي ﺁﻧﻬﺎ آﺎراآﺘﺮ ”‪ “&H‬را ﻗﺮار دهﻴﺪ.‬ ‫آﺎراآﺘﺮ و ﻧﻤﺎد ﻣﻌﺎدل ﺑﺮاي اﻋﺪاد در ﻣﺒﻨﺎي ٨، آﺎراآﺘﺮ ”0&“ ﻣﻲ ﺑﺎﺷﺪ.‬ ‫ﻓﺮض آﻨﻴﺪ ﻣﻘﺎدﻳﺮ زﻳﺮ ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﺑﺎﺷﻨﺪ:‬ ‫77‪Dvalue =199 : Ovalue =&O‬‬ ‫ﺣﺎل دﺳﺘﻮر )‪ ،Oct(Dvalue‬ﻣﻘﺪار رﺷﺘﻪ اي ”703“ و دﺳﺘﻮر )‪ Hex(Dvalue‬ﻣﻘﺪار رﺷﺘﻪ اي‬ ‫”‪ “3F‬را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﻣﻲ ﺗﻮاﻧﻴﺪ از آﺎراآﺘﺮهﺎي ﻣﻌﺎدل اﻳﻦ ﻣﺘﺪهﺎ ﻧﻴﺰ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ. ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)‪MsgBox (“The number 3F in decimal is “ & &H3F‬‬ ‫ﻣﻘﺪاري آﻪ ﻧﺸﺎن دادﻩ ﻣﻲ ﺷﻮد، ﻋﺪد 36 ﺧﻮاهﺪ ﺑﻮد.‬ ‫)2‪Pow(value1,value‬‬ ‫اﻳﻦ ﻣﺘﺪ، دو ﻋﺪد را ﺑﻪ ﻋﻨﻮان ورودي درﻳﺎﻓﺖ آﺮدﻩ و ﻋﺪد اول را ﺑﻪ ﺗﻮان ﻋﺪد دوم ﻣﻲ رﺳﺎﻧﺪ.‬ ‫دﺳﺘﻮر زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫))3,2(‪Console.WriteLine(Math.Pow‬‬ ‫در ﺧﺮوﺟﻲ، ﻋﺪد ٨ ﻧﻤﺎﻳﺶ دادﻩ ﺧﻮاهﺪ ﺷﻮد. ٢ ﺑﻪ ﺗﻮان ٣ ﺑﺮاﺑﺮ ﺑﺎ ٨ اﺳﺖ.‬ ‫)‪Sin(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ، ﺳﻴﻨﻮس زاوﻳﻪ اي را ﺑﺮ ﺣﺴﺐ رادﻳﺎن ﻣﺤﺎﺳﺒﻪ و ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻋﺒﺎرﺗﻲ اﺳﺖ آﻪ ﺳﻴﻨﻮس ﺁن ﺑﺎﻳﺪ ﻣﺤﺎﺳﺒﻪ ﺷﻮد.‬ ‫ﻧﺘﻴﺠﻪ ﻣﺘﺪ )(‪ ،Sin‬ﻣﻘﺪاري ﺑﻴﻦ 1 ﺗﺎ 1– اﺳﺖ.‬ ‫ﻣﺜﺎل:‬ ‫57.0 = )3.2(‪Sin‬‬ ‫)‪Sqrt(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ، ﻣﺮﺑﻊ )ﻋﺪد ﺑﻪ ﺗﻮان ٣( ﻳﻚ ﻣﻘﺪار ﻋﺪدي را ﻣﺤﺎﺳﺒﻪ و ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻋﺪدي اﺳﺖ آﻪ ﺑﺎﻳﺪ ﻣﺮﺑﻊ ﺁن ﻣﺤﺎﺳﺒﻪ ﺷﻮد.‬ ‫)‪Tan(expression‬‬ ‫اﻳﻦ ﻣﺘﺪ، ﺗﺎﻧﮋاﻧﺖ زاوﻳﻪ اي را ﺑﺮ ﺣﺴﺐ رادﻳﺎن ﻣﺤﺎﺳﺒﻪ ﻣﻲ آﻨﺪ.‬ ‫ﻣﺜﺎل:‬ ‫21.1- = )3.2(‪Tan‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٦٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 37.
    ‫)‪:(Date and Time‬‬ ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ ﺗﺎرﻳﺦ و زﻣﺎن ﺳﺮ و آﺎر دارﻧﺪ‬ ‫ﺗﻮاﺑﻊ آﺎرﺑﺮدي و آﺎرﺁﻣﺪي ﺟﻬﺖ آﺎر ﺑﺎ ﺗﺎرﻳﺦ و زﻣﺎن در ‪ VB.NET‬وﺟـﻮد دارد آـﻪ ﻣﻤﻜـﻦ اﺳـﺖ در‬ ‫ﺑﺮﺧﻮرد اول ﺑﺎ اﻳﻦ ﺗﻮاﺑﻊ، از ﺗﻨﻮع ﺁﻧﻬﺎ ﺗﻌﺠﺐ آﻨﻴﺪ!‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: در ‪ ،VB‬ﻣﻘﺎدﻳﺮي آﻪ از ﻧﻮع ﺗﺎرﻳﺦ هﺴﺘﻨﺪ ﺑﺎﻳﺪ ﺣﺘﻤﺎ ﺑﻴﻦ دو ﻋﻼﻣﺖ )#( ﻗﺮار ﮔﻴﺮﻧﺪ.‬ ‫)(‪Now‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺗﺎرﻳﺦ و زﻣﺎن ﺟﺎري ﺳﻴﺴﺘﻢ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻣﺜﺎل:‬ ‫))(‪MsgBox(Now‬‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل، ﺧﺮوﺟﻲ دﺳﺘﻮر ﻓﻮق ﻣﻲ ﺗﻮاﻧﺪ ”‪ “02/10/2004 09:23:10 PM‬ﺑﺎﺷﺪ.‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﺗﺎرﻳﺦ و زﻣﺎن ﺑﺎ آﺎراآﺘﺮ ﺧﺎﻟﻲ )‪ (Blank‬از هﻢ ﺟﺪا ﺷﺪﻩ اﻧﺪ.‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: ﺑﺮاي اﺳﺘﺨﺮاج ﺗﻨﻬﺎ ﺗﺎرﻳﺦ ﻳﺎ زﻣﺎن ﺑﺮﮔﺸﺖ دادﻩ ﺷـﺪﻩ از اﻳـﻦ ﺗـﺎﺑﻊ، از ﺧـﻮاص ‪ Date‬و‬ ‫‪ TimeOfDay‬اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫)‪Console.WriteLine(Now.Date.ToString‬‬ ‫)‪Console.WriteLine(Now.TimeOfDay.ToString‬‬ ‫)‪Day(date‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ را ﺑﻪ ﻋﻨﻮان ورودي ﻣﻲ ﭘﺬﻳﺮد و روز ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔﺮ ﻣﻘﺪار ورودي، ﺗﺎرﻳﺦ 4002/51/21 ﺑﺎﺷﺪ، ﻣﻘﺪار ﺧﺮوﺟﻲ ﻋـﺪد 51 ﻳﻌﻨـﻲ روز‬ ‫ﺗﺎرﻳﺦ ﺧﻮاهﺪ ﺑﻮد.‬ ‫ﻣﺜﺎل زﻳﺮ روز ﺟﺎري ﺳﻴﺴﺘﻢ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫))(‪Day(Now‬‬ ‫)] ‪Weekday(date [,firstdayofweek‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻋﺪدي ﺑﻴﻦ 1 ﺗﺎ 7 را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ آﻪ ﻣﺸﺨﺺ آﻨﻨﺪﻩ روز هﻔﺘﻪ اﺳﺖ.‬ ‫ﻣﺜﻼ، 1 ﺑﺮاي ‪ 2 ،Sunday‬ﺑﺮاي ‪ Monday‬و ﺑﻪ هﻤﻴﻦ ﺗﺮﺗﻴﺐ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ date‬ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،firstdayofweek‬اوﻟﻴﻦ روز هﻔﺘﻪ را ﻣﺸﺨﺺ ﻣـﻲ آﻨـﺪ و ﻣـﻲ ﺗﻮاﻧـﺪ ﻳﻜـﻲ از‬ ‫ﻣﻘﺎدﻳﺮ زﻳﺮ را ﺑﭙﺬﻳﺮد:‬ ‫ﻣﻘﺪار اﻳﻦ ﺁرﮔﻮﻣﺎن ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ‪ Sunday‬ﻳﻌﻨﻲ ﻳﻜﺸﻨﺒﻪ اﺳﺖ.‬ ‫ﻣﻄﺎﺑﻖ ﺑﺎ ﺗﻨﻈﻴﻤﺎت ﺳﻴﺴﺘﻢ >>> 0 ﻳﺎ ‪System‬‬ ‫ﻳﻜﺸﻨﺒﻪ )ﻣﻘﺪار ﭘﻴﺶ ﻓﺮض( >>> 1 ﻳﺎ ‪Sunday‬‬ ‫دوﺷﻨﺒﻪ >>> 2 ﻳﺎ ‪Monday‬‬ ‫ﺳﻪ ﺷﻨﺒﻪ >>> 3 ﻳﺎ ‪Tuesday‬‬ ‫ﭼﻬﺎرﺷﻨﺒﻪ >>> 4 ﻳﺎ ‪Wednesday‬‬ ‫ﭘﻨﺞ ﺷﻨﺒﻪ >>> 5 ﻳﺎ ‪Thursday‬‬ ‫ﺟﻤﻌﻪ >>> 6 ﻳﺎ ‪Friday‬‬ ‫ﺷﻨﺒﻪ >>> 7 ﻳﺎ ‪Saturday‬‬ ‫)]] ‪WeekdayName(weekday [,abbreviate [,firstdayofweek‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ هﻤﺎﻧﻨﺪ ﺗﺎﺑﻊ )(‪ Weekday‬ﻋﻤﻞ ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ اﻳـﻦ ﺗـﺎﺑﻊ، ﻧـﺎم روز ﻣﻌـﺎدل ﻳـﻚ‬ ‫ﻋﺪد آﻪ ﺑﻴﻦ 1 ﺗﺎ 7 اﺳﺖ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ weekday‬ﻳﻚ ﻣﻘﺪار ﻋﺪدي ﺻﺤﻴﺢ اﺳﺖ و ﻋﺪدي ﺑﻴﻦ 1 ﺗﺎ 7 را ﻣﻲ ﭘﺬﻳﺮد.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،abbreviate‬ﻳﻚ ﻣﻘﺪار ﻣﻨﻄﻘﻲ )‪ (Boolean‬اﺳﺖ آﻪ ﻣﺸﺨﺺ ﻣـﻲ آﻨـﺪ ﺁﻳـﺎ‬ ‫ﻧﺎم روزي آﻪ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد ﺑﻪ ﺻﻮرت آﻮﺗـﺎﻩ و اﺧﺘـﺼﺎري ﺑﺎﺷـﺪ ﻳـﺎ ﺧﻴـﺮ. ﺑـﻪ ﻃـﻮر ﭘـﻴﺶ‬ ‫ﻓﺮض اﻳﻦ ﻣﻘﺪار ‪ False‬اﺳﺖ ﻳﻌﻨﻲ ﻧﺎم ﺑﻪ ﺻﻮرت آﺎﻣﻞ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٧٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 38.
    ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪firstdayofweek‬ﻧﻴﺰ اوﻟﻴﻦ روز هﻔﺘﻪ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ و ﻣﻲ ﺗﻮاﻧﺪ ﻳﻜـﻲ از‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ ﺁرﮔﻮﻣﺎن ‪ firstdayofweek‬از ﺗﺎﺑﻊ ‪ Weekday‬ﻣﻲ ﭘﺬﻳﺮد، ﺑﭙﺬﻳﺮد.‬ ‫ﻣﻘﺪار اﻳﻦ ﺁرﮔﻮﻣﺎن ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ‪ Sunday‬ﻳﻌﻨﻲ ﻳﻜﺸﻨﺒﻪ اﺳﺖ.‬ ‫)‪Month(date‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ از ﻣﻘﺪار ﺗﺎرﻳﺦ، ﻣﺎﻩ ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ آﻪ ﻋﺪدي ﺑﻴﻦ 1 ﺗﺎ 21 اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،date‬ﻣﻘﺪاري از ﻧﻮع ﺗﺎرﻳﺦ اﺳﺖ آﻪ ﻣﺎﻩ ﺁن ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺑﺮاي ﺑﻪ دﺳـﺖ ﺁوردن ﻋـﺪد ﻣﺘﻨـﺎﻇﺮ ﻣـﺎﻩ ﺟـﺎري ﺳﻴـﺴﺘﻢ از دﺳـﺘﻮر زﻳـﺮ اﺳـﺘﻔﺎدﻩ‬ ‫آﻨﻴﺪ:‬ ‫))(‪Month(Date‬‬ ‫)] ‪MonthName(month [,abbreviate‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻧﻴﺰ هﻤﺎﻧﻨﺪ ﺗﺎﺑﻊ )(‪ Month‬ﻋﻤﻞ ﻣﻲ آﻨﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت آﻪ ﺑﻪ ﺟﺎي ﻋﺪد ﻣـﺎﻩ، ﻧـﺎم ﻣـﺎﻩ را‬ ‫ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،month‬ﻣﻘﺪاري ﻋﺪدي و ﺑـﻴﻦ 1 ﺗـﺎ 21 اﺳـﺖ آـﻪ ﺑﺎﻳـﺪ ﻣـﺎﻩ ﻣﺘﻨـﺎﻇﺮ ﺁن ﺑﺮﮔـﺸﺖ دادﻩ‬ ‫ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،abbreviate‬ﻳﻚ ﻣﻘﺪار ﻣﻨﻄﻘﻲ )‪ (Boolean‬اﺳﺖ آﻪ ﻣﺸﺨﺺ ﻣـﻲ آﻨـﺪ ﺁﻳـﺎ‬ ‫ﻧﺎم ﻣﺎهﻲ آﻪ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد ﺑﻪ ﺻﻮرت آﻮﺗﺎﻩ و اﺧﺘـﺼﺎري ﺑﺎﺷـﺪ ﻳـﺎ ﺧﻴـﺮ. ﺑـﻪ ﻃـﻮر ﭘـﻴﺶ‬ ‫ﻓﺮض اﻳﻦ ﻣﻘﺪار ‪ False‬اﺳﺖ ﻳﻌﻨﻲ ﻧﺎم ﻣﺎﻩ ﺑﻪ ﺻﻮرت آﺎﻣﻞ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫)‪Year(date‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ از ﻣﻘﺪار ﺗﺎرﻳﺦ، ﺳﺎل ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻣﻘﺪاري آﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﻣﻲ ﮔﺮداﻧﺪ، ﻋﺪدي ﺑﻴﻦ 0 ﺗﺎ 9999 ﻣﻲ ﺑﺎﺷﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،date‬ﻣﻘﺪاري از ﻧﻮع ﺗﺎرﻳﺦ اﺳﺖ آﻪ ﺳﺎل ﺁن ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺑﺮاي ﺑﻪ دﺳﺖ ﺁوردن ﻋﺪد ﻣﺘﻨﺎﻇﺮ ﺳـﺎل ﺟـﺎري ﺳﻴـﺴﺘﻢ از دﺳـﺘﻮر زﻳـﺮ اﺳـﺘﻔﺎدﻩ‬ ‫آﻨﻴﺪ:‬ ‫))(‪Year(Now‬‬ ‫)‪Hour(time‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ از ﻣﻘﺪار زﻣﺎن، ﺑﺨﺶ ﺳﺎﻋﺖ ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻣﻘﺪاري آﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﻣﻲ ﮔﺮداﻧﺪ ﺑﻴﻦ 0 ﺗﺎ 42 اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،Time‬ﻣﻘﺪاري از ﻧﻮع زﻣﺎن )‪ (Time‬اﺳﺖ آﻪ ﺳﺎﻋﺖ ﺁن ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل دﺳﺘﻮر زﻳﺮ ﺳﺎﻋﺖ ﺟﺎري ﺳﻴﺴﺘﻢ را ﻧﺸﺎن ﻣﻲ دهﺪ:‬ ‫)))(‪Console.WriteLine(Hour(Now‬‬ ‫)‪Minute(time‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ از ﻣﻘﺪار زﻣﺎن، دﻗﻴﻘﻪ ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻣﻘﺪاري آﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﻣﻲ ﮔﺮداﻧﺪ ﺑﻴﻦ 0 ﺗﺎ 95 اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،time‬ﻣﻘﺪاري از ﻧﻮع زﻣﺎن اﺳﺖ آﻪ دﻗﻴﻘﻪ ﺁن ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل دﺳﺘﻮر زﻳﺮ دﻗﻴﻘﻪ ﺟﺎري ﺳﻴﺴﺘﻢ را ﻧﺸﺎن ﻣﻲ دهﺪ:‬ ‫)))(‪Console.WriteLine(Minute(Now‬‬ ‫)‪Second(time‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ از ﻣﻘﺪار زﻣﺎن، ﺛﺎﻧﻴﻪ ﺁن را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻣﻘﺪاري آﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﻣﻲ ﮔﺮداﻧﺪ ﺑﻴﻦ 0 ﺗﺎ 95 اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،time‬ﻣﻘﺪاري از ﻧﻮع زﻣﺎن اﺳﺖ آﻪ ﺛﺎﻧﻴﻪ ﺁن ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل دﺳﺘﻮر زﻳﺮ ﺛﺎﻧﻴﻪ ﺟﺎري ﺳﻴﺴﺘﻢ را ﻧﺸﺎن ﻣﻲ دهﺪ:‬ ‫)))(‪Console.WriteLine(Second(Now‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٨٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 39.
    ‫)‪DateSerial(year,month,day‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺳﻪ ﻋﺪد ﺻﺤﻴﺢ را ﺑﻪ ﻋﻨﻮان ورودي درﻳﺎﻓﺖ آﺮدﻩ و ﺁن را ﺑﻪ ﺗﺎرﻳﺦ ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن هﺎي ‪ month،year‬و ‪ day‬ﺑﻪ ﺗﺮﺗﻴﺐ ﺳﺎل، ﻣﺎﻩ و روز هﺴﺘﻨﺪ.‬ ‫دﺳﺘﻮر زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫))1,01,2002(‪Console.WriteLine(DateSerial‬‬ ‫ﺧﺮوﺟﻲ اﻳﻦ دﺳﺘﻮر، رﺷﺘﻪ ي ”2002/01/10“ ﺧﻮاهﺪ ﺑﻮد.‬ ‫هﻤﭽﻨﻴﻦ از اﻳﻦ ﺗﺎﺑﻊ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺟﻬﺖ ﺑﺮﺧﻲ ﻣﺤﺎﺳﺒﺎت ﺑﺮ روي ﻣﻘﺪار ﺗﺎرﻳﺦ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻓﺮض آﻨﻴﺪ ﻣﻲ ﺧﻮاهﻴﺪ ﺑﺪاﻧﻴﺪ آﻪ ﻧﻮدﻣﻴﻦ روز ﺳـﺎل در ﭼـﻪ ﺗـﺎرﻳﺨﻲ از ﺳـﺎل ﻗـﺮار‬ ‫ﺧﻮاهﺪ ﮔﺮﻓﺖ. ﻣﻲ ﺗﻮاﻧﻴﺪ از دﺳﺘﻮر زﻳﺮ ﺟﻬﺖ ﺁﮔﺎهﻲ از اﻳﻦ ﻣﻮﺿﻮع اﺳﺘﻔﺎدﻩ آﻨﻴﺪ:‬ ‫))09,1,6991(‪Console.WriteLine(DateSerial‬‬ ‫ﺧﺮوﺟﻲ اﻳﻦ دﺳﺘﻮر، ﻋﺒﺎرت ”6991/03/30“ ﺧﻮاهﺪ ﺑﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎﻟﻲ دﻳﮕـﺮ ﻣـﻲ ﺧـﻮاهﻴﻢ ﺑـﺪاﻧﻴﻢ آـﻪ ٠٠٠١ روز ﺑﻌـﺪ از ﺗـﺎرﻳﺦ ﻓﻌﻠـﻲ ﺳﻴـﺴﺘﻢ در ﭼـﻪ‬ ‫ﺗﺎرﻳﺨﻲ ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ. ﭘﺲ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ:‬ ‫))0001+)‪Console.WriteLine(DateSerial(Year(Now.Date),Month(Now.Date),Weekday(Now.Date‬‬ ‫ﺷﻤﺎ هﻤﭽﻨﻴﻦ ﻗﺎدر ﺑﻪ اﺿﺎﻓﻪ آﺮدن ﻳﺎ آﻢ آﺮدن )ﺗﻔﺮﻳﻖ آﺮدن( ﻳﻚ ﻋﺪد ﻣﺘﻨﺎﻇﺮ ﻣﺎﻩ هﺎ ﺑﻪ ﺁرﮔﻮﻣـﺎن‬ ‫‪ month‬و هﻤﭽﻨﻴﻦ ﻳﻚ ﻋﺪد ﻣﺘﻨﺎﻇﺮ ﺳﺎل ﺑﻪ ﺁرﮔﻮﻣﺎن ‪ year‬هﺴﺘﻴﺪ.‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﺗﻌﺪاد روزهﺎي هﺮ ﻣﺎﻩ در اﻳﻦ ﺗﺎﺑﻊ ٠٣ روز اﺳﺖ.‬ ‫)‪DateValue(date‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻋﺒﺎرت رﺷﺘﻪ اي را ﺑﻪ ﻋﻨﻮان ورودي درﻳﺎﻓﺖ آﺮدﻩ و ﺁن را ﺑﻪ ﻳﻚ ﻣﻘـﺪار از ﻧـﻮع ﺗـﺎرﻳﺦ‬ ‫ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔﺮ اﻳﻦ ﺗﺎﺑﻊ را ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺑﻪ آﺎر ﺑﺒﺮﻳﻢ:‬ ‫))”2002 ,52 ‪Console.WriteLine(DateValue(“December‬‬ ‫ﻋﺒﺎرﺗﻲ آﻪ در ﺧﺮوﺟﻲ ﭼﺎپ ﻣﻲ ﺷﻮد، ”2002/52/21“ ﺧﻮاهﺪ ﺑﻮد.‬ ‫ﻳﻜﻲ از آﺎرﺑﺮدهﺎي ﺳﻮدﻣﻨﺪ و ﻣﻔﻴﺪ اﻳﻦ ﺗﺎﺑﻊ در هﻨﮕﺎﻣﻲ اﺳـﺖ آـﻪ ﺑـﺎ ﺗـﺎﺑﻊ )(‪ DateDiff‬ﺑـﻪ آـﺎر‬ ‫رود.‬ ‫ﺗﺎﺑﻊ )(‪ DateDiff‬در اداﻣﻪ ﺗﻮﺿﻴﺢ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﻓﺮض آﻨﻴﺪ ﻣﻲ ﺧﻮاهﻴﻢ ﺗﻌﺪاد روزهﺎي ﺑﻴﻦ دو ﺗﺎرﻳﺦ را ﻣﺤﺎﺳﺒﻪ آﻨﻴﻢ:‬ ‫دﺳﺘﻮر زﻳﺮ اﻳﻦ آﺎر را ﺑﺮاي ﻣﺎ اﻧﺠﺎم ﻣﻲ دهﺪ:‬ ‫_ ,)”3991/52/21“(‪Console.WriteLine((DateDiff(DateInterval.Day,DateValue‬‬ ‫)))” 6991/52/21“(‪DateValue‬‬ ‫ﻋﺪدي آﻪ در ﺧﺮوﺟﻲ ﻇﺎهﺮ ﺧﻮاهﺪ ﺷﺪ، 6901 ﻳﻌﻨﻲ ﺗﻌﺪاد روزهـﺎي ﺑـﻴﻦ اﻳـﻦ دو ﺗـﺎرﻳﺦ ﺧﻮاهـﺪ‬ ‫ﺑﻮد.‬ ‫)‪TimeSerial(hours,minutes,seconds‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺳﻪ ﻋﺪد ﺻﺤﻴﺢ را ﺑﻪ زﻣﺎن ﻣﺸﺨﺼﻲ ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن هﺎي ‪ Minute ،Hour‬و ‪ Second‬ﺑﻪ ﺗﺮﺗﻴﺐ اﻋﺪاد ﺻﺤﻴﺤﻲ هﺴﺘﻨﺪ آﻪ ﺳـﺎﻋﺖ، دﻗﻴﻘـﻪ‬ ‫و ﺛﺎﻧﻴﻪ را آﻪ ﺑﺎﻳﺪ ﺑﻪ زﻣﺎن ﺗﺒﺪﻳﻞ ﺷﻮﻧﺪ، ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)55,01,4(‪TimeSerial‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻣﻘﺪار "‪ “4:10:55 AM‬را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻣﻌﻤﻮﻻ ﺑﺮاي ﻣﺤﺎﺳﺒﻪ ي زﻣﺎن ﺑﻪ آﺎر ﻣﻲ رود.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٩٣‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 40.
    ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل،ﻓﺮاﺧﻮاﻧﻲ ﺗﺎﺑﻊ )(‪ TimeSerial‬ﺑﻪ ﺷﻜﻞ زﻳـﺮ، ٢ ﺳـﺎﻋﺖ و ٥١ دﻗﻴﻘـﻪ و ٢٣ ﺛﺎﻧﻴـﻪ‬ ‫ﻗﺒﻞ از ﺳﺎﻋﺖ ‪ 4:13:40 PM‬را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫)23- 04,51- 31,2- 61(‪TimeSerial‬‬ ‫زﻣﺎن ﺑﺮﮔﺸﺘﻲ، ‪ 1:58:08 PM‬ﺧﻮاهﺪ ﺑﻮد.‬ ‫)‪TimeValue(time‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي را درﻳﺎﻓﺖ آﺮدﻩ و ﺁن را ﺑﻪ ﻣﻘﺪار زﻣﺎﻧﻲ ﺗﺒﺪﻳﻞ ﻣﻲ آﻨﺪ.‬ ‫هﻤﺎﻧﻨﺪ ﺗﺎﺑﻊ )(‪ ،DateValue‬اﻳﻦ ﺗﺎﺑﻊ ﻧﻴﺰ ﻣﻲ ﺗﻮاﻧﺪ ﺟﻬﺖ اﻧﺠـﺎم ﻋﻤﻠﻴـﺎﺗﻲ ﻧﻈﻴـﺮ ﺟﻤـﻊ ﻳـﺎ ﺗﻔﺮﻳـﻖ‬ ‫زﻣﺎن هﺎ ﺑﻪ آﺎر رود.‬ ‫)‪DateAdd(interval,number,date‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ هﻤﺎن ﻃﻮر آﻪ از ﻧـﺎم ﺁن ﻧﻴـﺰ ﭘﻴﺪاﺳـﺖ، ﻣﻘـﺪاري را ﺑـﻪ ﺗـﺎرﻳﺨﻲ ﻣـﺸﺨﺺ اﺿـﺎﻓﻪ آـﺮدﻩ و‬ ‫ﺗﺎرﻳﺦ ﺟﺪﻳﺪ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،interval‬ﻳﻚ واﺣﺪ زﻣﺎﻧﻲ هﻤﺎﻧﻨﺪ روز، ﺳﺎﻋﺖ، هﻔﺘﻪ و … اﺳﺖ آـﻪ ﻓﺎﺻـﻠﻪ دورﻩ اي را‬ ‫ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ ﺗﺎرﻳﺦ ﺟﺪﻳﺪ ﺑﺎﻳﺪ ﺑﺮ ﺣﺴﺐ ﺁن ﻣﺤﺎﺳـﺒﻪ و ﺑﺮﮔـﺸﺖ دادﻩ ﺷـﻮد و ﻣـﻲ ﺗﻮاﻧـﺪ‬ ‫ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ زﻳﺮ را ﺑﭙﺬﻳﺮد:‬ ‫ﺳﺎل :‪Year‬‬ ‫ﻳﻚ ﭼﻬﺎرم ﺳﺎل ﻳﺎ ٣ ﻣﺎﻩ ﻳﺎ ﻳﻚ ﻓﺼﻞ :‪Quarter‬‬ ‫ﻣﺎﻩ :‪Month‬‬ ‫روز از ﺳﺎل :‪DayOfYear‬‬ ‫روز :‪Day‬‬ ‫روز از هﻔﺘﻪ :‪WeekDay‬‬ ‫هﻔﺘﻪ از ﺳﺎل :‪WeekOfYear‬‬ ‫ﺳﺎﻋﺖ :‪Hour‬‬ ‫دﻗﻴﻘﻪ :‪Minute‬‬ ‫ﺛﺎﻧﻴﻪ :‪Second‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،number‬ﺗﻌﺪاد هﺮ دورﻩ ي زﻣﺎﻧﻲ را ﻣﺸﺨﺺ ﻣﻲ آﻨـﺪ. ﻣـﺜﻼ ﻣﻤﻜـﻦ اﺳـﺖ ﺑﺨـﻮاهﻴﻢ‬ ‫ﺑﺪاﻧﻴﻢ آﻪ ٣ ﻣﺎﻩ ﺑﻌﺪ از ﺗﺎرﻳﺦ ﻓﻌﻠﻲ ﺳﻴﺴﺘﻢ ﭼﻪ ﺗﺎرﻳﺨﻲ ﻣﻲ ﺷﻮد ﭘﺲ اﻳﻦ ﭘـﺎراﻣﺘﺮ را ﺑﺮاﺑـﺮ ﺑـﺎ ٣‬ ‫ﻗﺮار ﻣﻲ دهﻴﻢ.‬ ‫ﻧﻜﺘﻪ: اﮔﺮ اﻳﻦ ﺁرﮔﻮﻣﺎن ﻋﺪدي ﻣﺜﺒﺖ ﺑﺎﺷﺪ، ﺗﺎرﻳﺨﻲ آﻪ ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﺪ ﺷﺪ ﻣﺮﺑﻮط ﺑـﻪ ﺁﻳﻨـﺪﻩ‬ ‫اﺳﺖ و اﮔﺮ اﻳﻦ ﺁرﮔﻮﻣﺎن، ﻣﻨﻔﻲ ﺑﺎﺷﺪ، ﺗﺎرﻳﺨﻲ آﻪ ﻧﺸﺎن دادﻩ ﻣﻲ ﺷﻮد ﻣﺮﺑﻮط ﺑـﻪ ﮔﺬﺷـﺘﻪ ﻣـﻲ‬ ‫ﺑﺎﺷﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ date‬ﻧﻴﺰ ﺗﺎرﻳﺨﻲ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ آﻪ ﻋﻤﻠﻴﺎت ﺑﺎﻳﺪ ﺑﺮ روي ﺁن اﻧﺠﺎم ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻣﻲ ﺧﻮاهﻴﻢ ﺑﺪاﻧﻴﻢ آﻪ ١ ﻣﺎﻩ ﺑﻌﺪ از ١٣ دﺳـﺎﻣﺒﺮ ﺳـﺎل ٢٠٠٢، ﭼـﻪ ﺗـﺎرﻳﺨﻲ ﻣـﻲ‬ ‫ﺷﻮد. ﭘﺲ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ:‬ ‫))#2002/13/21#,1,‪Console.WriteLine(DateAdd(DateInterval.Month‬‬ ‫ﻧﺘﻴﺠﻪ اﻳﻦ دﺳﺘﻮر، ﻋﺒﺎرت ”‪ “1/31/2003 12:00:00 AM‬ﺧﻮاهﺪ ﺑﻮد.‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﺎ ﺣﺪ زﻳﺎدي ﺷﺒﻴﻪ ﺑﻪ ﺗﺎﺑﻊ )(‪ DateSerial‬اﺳﺖ آﻪ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪ ﺑﺎ اﻳـﻦ ﺗﻔـﺎوت آـﻪ‬ ‫ﺗﻌﺪاد روزهﺎي هﺮ ﻣﺎﻩ در اﻳﻦ ﺗﺎﺑﻊ ﺑﻨﺎ ﺑﻪ ﻧﺎم ﻣﺎﻩ ﻓﺮق ﻣﻲ آﻨﺪ ﻣﺜﻼ ﻣﻤﻜﻦ اﺳﺖ ﻳﻚ ﻣﺎﻩ ٠٣ ﻳـﺎ ١٣‬ ‫روز ﺑﺎﺷﺪ اﻣﺎ ﺗﻌﺪاد روزهﺎي ﻣﺎﻩ در ﺗﺎﺑﻊ )(‪ ،DateSerial‬ﺛﺎﺑﺖ و ٠٣ روز ﻣﻲ ﺑﺎﺷﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫#2002/13/1#= 1‪day‬‬ ‫)))1‪Console.WriteLine(DateSerial(year(day1),month(day1)+1,day(day‬‬ ‫ﻧﺘﻴﺠﻪ ﻋﺒﺎرت، ”20/2/3“ ﺧﻮاهﺪ ﺑﻮد آﻪ ﻳﻚ ﺗﺎرﻳﺦ در ﻣﺎﻩ ﻣﺎرس اﺳﺖ ﻧﻪ ﻓﻮرﻳﻪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٠٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 41.
    ‫)]] ‪DateDiff(interval,date1,date2 [,firstdayofweek[,firstweekofyear‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺷﻜﻞ ﭘﻴﺸﺮﻓﺘﻪ ﺗﺮ ﺗﺎﺑﻊ )(‪ DateAdd‬اﺳﺖ و اﺧﺘﻼف ﺑﻴﻦ دو ﺗﺎرﻳﺦ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ interval‬ﻳﻚ ﻣﻘﺪار ﺛﺎﺑﺖ اﺳﺖ و ﻓﻮاﺻـﻞ ﺑـﻴﻦ دورﻩ اي را ﻣـﺸﺨﺺ ﻣـﻲ آﻨـﺪ آـﻪ ﺷـﻤﺎ‬ ‫ﺑﺮاي ﻣﺤﺎﺳﺒﻪ اﺧﺘﻼف ﺑﻴﻦ دو ﺗﺎرﻳﺦ ﺑﻪ آﺎر ﻣﻲ ﺑﺮﻳﺪ.‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ اﻳﻦ ﺁرﮔﻮﻣﺎن ﻣﻲ ﺗﻮاﻧﺪ ﺑﭙﺬﻳﺮد هﻤﺎن ﻣﻘﺎدﻳﺮي هﺴﺘﻨﺪ آﻪ ﺁرﮔﻮﻣـﺎن ‪ interval‬ﺗـﺎﺑﻊ‬ ‫)(‪ DateAdd‬ﻣﻲ ﺗﻮاﻧﺪ ﺑﭙﺬﻳﺮد.‬ ‫ﺁرﮔﻮﻣﺎن هﺎي 1‪ date‬و 2‪ date‬ﺗﺎرﻳﺦ هﺎﻳﻲ هﺴﺘﻨﺪ آﻪ اﺧﺘﻼف ﺁﻧﻬﺎ ﺑﺎﻳﺪ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﻧﻜﺘﻪ: هﻤﻴﺸﻪ ﻣﻘﺪار 2‪ date‬از 1‪ date‬آﻢ ﻣﻲ ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن هﺎي اﺧﺘﻴﺎري ‪ firstdayofweek‬و ‪ firstweekofyear‬ﻧﻴﺰ ﺑﻪ ﺗﺮﺗﻴﺐ، اوﻟﻴﻦ روز هﻔﺘـﻪ و‬ ‫اوﻟﻴﻦ هﻔﺘﻪ ﺳﺎل را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﻨﺪ.‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ اﻳﻦ ﺁرﮔﻮﻣﺎن هﺎ ﻣﻲ ﺗﻮاﻧﻨﺪ ﺑﭙﺬﻳﺮﻧـﺪ، هﻤـﺎن ﻣﻘـﺎدﻳﺮ ﺁرﮔﻮﻣـﺎن ‪ firstdayofweek‬از‬ ‫ﺗﺎﺑﻊ )(‪ Format‬اﺳﺖ آﻪ ﭘﻴﺸﺘﺮ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪ. )ﺑﻪ ﺗﻮﺿﻴﺤﺎت ﺗﺎﺑﻊ )(‪ format‬ﻣﺮاﺟﻌﻪ آﻨﻴﺪ(‬ ‫ﻣﺜﻼ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ از اﻳﻦ ﺗﺎﺑﻊ ﺑﺮاي اﻃﻼع از ﺗﻌﺪاد روزهﺎ، هﻔﺘﻪ هﺎ، ﺛﺎﻧﻴﻪ هﺎ و … ﺑﻴﻦ دو ﺗـﺎرﻳﺦ‬ ‫اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﻣﺜﺎل زﻳﺮ ﺗﻌﺪاد روزهﺎي ﺑﻴﻦ ﻳﻚ ﺗﺎرﻳﺦ ﻣﺸﺨﺺ ﺷﺪﻩ و ﺗﺎرﻳﺦ ﻓﻌﻠﻲ ﺳﻴﺴﺘﻢ را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ:‬ ‫‪Dim century As Date‬‬ ‫#0002/1/1#= ‪century‬‬ ‫)))(‪MsgBox(DateDiff(DateInterval.Day,century,Now‬‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: ﺗﻮاﺑﻊ ‪ DateDiff‬و ‪ TimeSerial‬در ﭘﺮوژﻩ هـﺎي وب و ﻣﺨـﺼﻮﺻﺎ ﻓـﻮروم هـﺎﻳﻲ آـﻪ ﺑـﻪ‬ ‫وﺳﻴﻠﻪ ي زﺑﺎن ‪ ASP.NET‬اﻳﺠﺎد ﻣﻲ ﺷﻮﻧﺪ، آﺎرﺑﺮد ﻓﺮاواﻧﻲ دارﻧﺪ.‬ ‫ﻳﻚ ﻧﻜﺘﻪ ي ﺑﺴﻴﺎر ﻣﻬﻢ: ﻧﻜﺘﻪ اي آﻪ ﻣﺘﺎﺳﻔﺎﻧﻪ در اآﺜﺮ ﭘﺮوژﻩ هﺎي وب در اﻳﺮان رﻋﺎﻳﺖ ﻧﻤﻲ ﺷﻮد‬ ‫اﻳﻦ اﺳﺖ آﻪ ﺳﺎﻋﺖ رﺳﻤﻲ اﻳﺮان در روز اول ﻓﺮوردﻳﻦ ﻳﻚ ﺳﺎﻋﺖ ﺑﻪ ﺟﻠـﻮ آـﺸﻴﺪﻩ ﻣـﻲ ﺷـﻮد و‬ ‫در اﻳﻦ ﺣﺎﻟﺖ، ﺳﺎﻋﺖ آﺸﻮر ﻣﺎ از ﮔﺮﻳﻨﻮﻳﭻ، ٠٣:٤ ﺳـﺎﻋﺖ ﺟﻠـﻮﺗﺮ اﺳـﺖ، در ﺣـﺎﻟﻲ آـﻪ در روز ١٣‬ ‫ﺷﻬﺮﻳﻮر ﻳﻚ ﺳﺎﻋﺖ ﺑﻪ ﻋﻘﺐ آﺸﻴﺪﻩ ﻣﻲ ﺷﻮد و ﺑﻪ ﺣﺎﻟﺖ اوﻟﻴﻪ ﺧﻮد ﺑﺎز ﻣﻲ ﮔﺮدد ﻳﻌﻨـﻲ 5.3+‬ ‫‪GMT‬‬ ‫)]] ‪DatePart(interval,date [,firstdayofweek [,firstweekofyear‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺑﺨﺸﻲ از ﻳﻚ ﺗﺎرﻳﺦ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ interval‬ﺑﺨﺸﻲ اﺳﺖ آﻪ ﺑﺎﻳﺪ از ﺗﺎرﻳﺦ اﺳﺘﺨﺮاج ﺷﻮد و هﻤﺎن ﻣﻘﺎدﻳﺮي را ﻣـﻲ ﭘـﺬﻳﺮد‬ ‫آﻪ ﻣﻲ ﺗﻮان ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ ﺗﺎرﻳﺦ و زﻣﺎن در ﺗﺎﺑﻊ )(‪ Format‬ﺑﻪ آﺎر ﺑﺮد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ date‬ﻧﻴﺰ ﺗﺎرﻳﺨﻲ اﺳﺖ آﻪ ﻗﺴﻤﺘﻲ از ﺁن ﺑﺎﻳﺪ اﺳﺘﺨﺮاج ﺷﻮد.‬ ‫ﺁرﮔﻮﻣـــﺎن هـــﺎي اﺧﺘﻴـــﺎري ‪ firstdayofweek‬و ‪ firstweekofyear‬ﻧﻴـــﺰ در ﺗـــﺎﺑﻊ )(‪DateDiff‬‬ ‫ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻧﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻓﺮض ﻣﻲ آﻨﻴﻢ ﺗﺎرﻳﺦ ﺟﺎري ﺳﻴﺴﺘﻢ، ٣٢ اآﺘﺒﺮ ﺳﺎل ١٠٠٢ ﻣﻴﻼدي اﺳﺖ.‬ ‫دﺳﺘﻮرات زﻳﺮ ﻧﺘﺎﻳﺞ ﻣﺨﺘﻠﻔﻲ را ﺑﻪ ﻣﺎ ﻧﺸﺎن ﻣﻲ دهﻨﺪ آﻪ ﻧﺘﻴﺠﻪ ﺑﻪ ﺻﻮرت ﭘﺮرﻧﮓ ﺗـﺮ ﻧﻤـﺎﻳﺶ دادﻩ‬ ‫ﺷﺪﻩ اﺳﺖ:‬ ‫‪Dim Day1 As DateTime‬‬ ‫)(‪day1 =Now‬‬ ‫))1‪Console.WriteLine(DatePart(“yyyy ”,day‬‬ ‫1002‬ ‫))1‪Console.WriteLine(DatePart(“q ”,day‬‬ ‫3‬ ‫))1‪Console.WriteLine(DatePart(“m ”,day‬‬ ‫01‬ ‫))1‪Console.WriteLine(DatePart(“d ”,day‬‬ ‫32‬ ‫))1‪Console.WriteLine(DatePart(“w ”,day‬‬ ‫3‬ ‫))1‪Console.WriteLine(DatePart(“ww ”,day‬‬ ‫34‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫١٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 42.
    Console.WriteLine(DatePart(“h ”,day1)) 15 Console.WriteLine(DatePart(“n ”,day1)) 3 Console.WriteLine(DatePart(“s”,day1)) 30 ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ٤٢ Visual Basic.NET ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ‬
  • 43.
    ‫ﺗﻮاﺑﻌﻲ آﻪ ﺟﻬﺖاﻧﺠﺎم ﻋﻤﻠﻴﺎت ورودي/ﺧﺮوﺟﻲ )‪ (I/O‬ﺑﺮ روي ﻓﺎﻳﻞ هﺎ ﻣﻮرد‬ ‫اﺳﺘﻔﺎدﻩ ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ )‪:(File I/O‬‬ ‫ﻳﻜﻲ از ﺟﻨﺒﻪ هﺎي ﻣﻬﻢ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ در هﺮ زﺑﺎن، ﻗﺎﺑﻠﻴﺖ دﺳﺘﺮﺳﻲ و ﻣـﺪﻳﺮﻳﺖ ﻓﺎﻳـﻞ هـﺎ ﻣـﻲ‬ ‫ﺑﺎﺷﺪ.‬ ‫در وﻳﮋوال ﺑﻴﺴﻴﻚ، ٣ ﻧﻮع ﻓﺎﻳﻞ وﺟﻮد دارد:‬ ‫١( ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ.‬ ‫٢( ﻓﺎﻳﻞ هﺎي ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ.‬ ‫٣( ﻓﺎﻳﻞ هﺎي ﺑﺎﻳﻨﺮي.‬ ‫ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ اﻏﻠﺐ ﻓﺎﻳـﻞ هـﺎي ﻣﺘﻨـﻲ )‪ (Text‬هـﺴﺘﻨﺪ. ﺑـﻪ ﻋﺒـﺎرت دﻳﮕـﺮ ﺷـﻤﺎ ﻣـﻲ ﺗﻮاﻧﻴـﺪ‬ ‫اﻳﻨﮕﻮﻧﻪ ﻓﺎﻳﻞ هﺎ را ﺑﺎ هﺮ وﻳﺮاﻳﺸﮕﺮ ﻣﺘﻨﻲ هﻤﺎﻧﻨﺪ ‪ Notepad‬ﺑﺎز آﻨﻴﺪ.‬ ‫در اﻳﻨﮕﻮﻧﻪ ﻓﺎﻳﻞ هﺎ هﺮ آﺎراآﺘﺮ ذﺧﻴﺮﻩ ﺷﺪﻩ در ﻓﺎﻳﻞ، ﻳﻚ ﺑﺎﻳﺖ را اﺷﻐﺎل ﻣﻲ آﻨﺪ.‬ ‫ﺗﻤﺎﻣﻲ اﻃﻼﻋﺎت ذﺧﻴﺮﻩ ﺷﺪﻩ در ﻓﺎﻳﻞ هﺎي ﻣﺘﻨﻲ ﺑﻪ ﺻﻮرت رﺷﺘﻪ اي ذﺧﻴﺮﻩ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫ﻣﺜﻼ ﻣﻘﺎدﻳﺮ ﻋﺪدي ﺑﻪ ﺻﻮرت ‪ Integer‬ﻳﺎ ‪ Double‬ذﺧﻴﺮﻩ ﻧﻤـﻲ ﺷـﻮﻧﺪ ﺑﻠﻜـﻪ ﺑـﻪ ﺻـﻮرت ‪String‬‬ ‫ﻋﻤﻞ ذﺧﻴﺮﻩ ﺳﺎزي ﺁﻧﻬﺎ اﻧﺠﺎم ﻣﻲ ﺷﻮد.‬ ‫ﻋﻤﻞ ﺧﻮاﻧﺪن ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ، ﺑﻪ ﺗﺮﺗﻴﺐ ﻳﻌﻨﻲ از اﺑﺘﺪا ﺗﺎ اﻧﺘﻬﺎي ﻓﺎﻳﻞ و ﺧﻂ ﺑﻪ ﺧـﻂ اﻧﺠـﺎم ﻣـﻲ‬ ‫ﺷﻮد ﺑﻨﺎﺑﺮاﻳﻦ ﺷﻤﺎ ﻧﻤﻲ ﺗﻮاﻧﻴﺪ در ﻳﻚ زﻣﺎن در ﻳـﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ هـﻢ اﻃﻼﻋـﺎت را ﺑﺨﻮاﻧﻴـﺪ و هـﻢ‬ ‫اﻃﻼﻋﺎت را ﺑﻨﻮﻳﺴﻴﺪ.‬ ‫اﮔﺮ ﻗﺼﺪ ﺧﻮاﻧـﺪن و ﻧﻮﺷـﺘﻦ هﻤﺰﻣـﺎن در و از ﻳـﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ را دارﻳـﺪ، ﺑﺎﻳـﺪ از دو ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ‬ ‫اﺳﺘﻔﺎدﻩ آﻨﻴﺪ. ﻳﻜﻲ ﺑﺮاي ﺧﻮاﻧﺪن اﻃﻼﻋﺎت و ﻳﻜﻲ ﺑﺮاي ﻧﻮﺷﺘﻦ اﻃﻼﻋﺎت درون ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ.‬ ‫اﮔﺮ در ﺑﺮﻧﺎﻣﻪ اي آﻪ ﻣﻲ ﻧﻮﻳﺴﻴﺪ ﺑﻪ ﻃﻮر ﻣﻜﺮر ﺑﺎ ﻓﺎﻳﻞ هـﺎ ﺳـﺮو آـﺎر دارﻳـﺪ ﺑـﻪ ﮔﻮﻧـﻪ اي آـﻪ ﺑﺎﻳـﺪ‬ ‫ﻣﺮﺗﺒﺎ ﻣﺤﺘﻮﻳﺎت ﻳﻚ ﻓﺎﻳﻞ ﺧﻮاﻧﺪﻩ ﺷﻮد و ﭘﺲ از اﻧﺠـﺎم ﺗﻐﻴﻴـﺮات ﻣﺠـﺪدا ذﺧﻴـﺮﻩ ﺷـﻮد، ﺑﺎﻳـﺪ از ﻓﺎﻳـﻞ‬ ‫هﺎي ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫اﻳﻦ ﻓﺎﻳﻞ هﺎ در ﻣﻘﺎﻳﺴﻪ ﺑﺎ ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ از ﺳﺮﻋﺖ ﺑﻴﺸﺘﺮي ﺑﺮﺧﻮردارﻧﺪ.‬ ‫ﻓﺎﻳﻞ هﺎي ﺗﺼﺎدﻓﻲ ﻧﻴﺰ هﻤﺎﻧﻨﺪ ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒـﻲ ﺑـﺮاي ﻣﻘـﺎدﻳﺮي از ﻧـﻮع رﺷـﺘﻪ اي ﺑـﻪ ازاي هـﺮ‬ ‫آﺎراآﺘﺮ، ﻳﻚ ﺑﺎﻳﺖ را اﺧﺘﺼﺎص ﻣﻲ دهﻨﺪ اﻣﺎ ﺑـﺮ ﺧـﻼف ﻓﺎﻳـﻞ هـﺎي ﺗﺮﺗﻴﺒـﻲ، در اﻳـﻦ ﻧـﻮع ﻓﺎﻳـﻞ هـﺎ‬ ‫ﻣﻘﺎدﻳﺮ ﻋﺪدي ﺑﺎ ﻧﻮع ﺧﺎص ﺧﻮد ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ ﻣﺜﻼ ‪ Integer‬ﻳﺎ ‪.Double‬‬ ‫ﺑﺮاي ﻧﻤﺎﻳﺶ ﻓﺎﻳـﻞ هـﺎي ﺗـﺼﺎدﻓﻲ در ﻣﺤـﻴﻂ ‪ Dos‬ﻣـﻲ ﺗﻮاﻧﻴـﺪ ﺑـﺎ ﻧﻮﺷـﺘﻦ دﺳـﺘﻮر ‪ TYPE‬در ﺧـﻂ‬ ‫ﻓﺮﻣﺎن، ﻣﻘﺎدﻳﺮ رﺷﺘﻪ اي ذﺧﻴﺮﻩ ﺷﺪﻩ در اﻳﻦ ﻓﺎﻳﻞ هﺎ را ﻣﺸﺎهﺪﻩ آﻨﻴـﺪ اﻣـﺎ ﻗـﺎدر ﺑـﻪ دﻳـﺪن اﻋـﺪاد‬ ‫ذﺧﻴﺮﻩ ﺷﺪﻩ ﻧﻴﺴﺘﻴﺪ.‬ ‫ﻓﺎﻳﻞ هﺎي ﺗﺼﺎدﻓﻲ ﺑﺮاي ذﺧﻴﺮﻩ آﺮدن دادﻩ هﺎﻳﻲ آـﻪ در ﺑﺨـﺶ هـﺎﻳﻲ ﺑـﺎ ﻃـﻮل ﻣـﺸﺨﺺ دﺳـﺘﻪ‬ ‫ﺑﻨﺪي ﺷﺪﻩ اﻧﺪ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ.‬ ‫اﻳﻦ ﺑﺨﺶ هﺎ را اﺻﻄﻼﺣﺎ رآﻮرد ﻣﻲ ﻧﺎﻣﻴﻢ.‬ ‫ﻓﺎﻳﻞ هﺎي ﺗﺼﺎدﻓﻲ ﺑﻪ ﺷﻤﺎ اﻳﻦ اﻣﻜﺎن را ﻣﻲ دهﻨﺪ آﻪ ﺑﻪ هﺮ رآﻮرد دﻟﺨـﻮاﻩ در ﻓﺎﻳـﻞ ﺑـﻪ ﺳـﺮﻋﺖ‬ ‫دﺳﺘﺮﺳﻲ داﺷﺘﻪ ﺑﺎﺷﻴﺪ.‬ ‫از ﺁﻧﺠﺎﻳﻲ آﻪ ﺗﻤﺎﻣﻲ رآﻮردهﺎ در ﻓﺎﻳﻞ ﺗﺼﺎدﻓﻲ داراي ﻃـﻮل ﺛـﺎﺑﺘﻲ هـﺴﺘﻨﺪ، اﺿـﺎﻓﻪ آـﺮدن رآـﻮرد‬ ‫ﺟﺪﻳﺪ در ﻓﺎﻳﻞ ﺑﺎ اﺧﺘﺼﺎص دادن ﻳﻚ ﺷﻤﺎرﻩ ﺷﺎﺧﺺ )‪ (index‬ﺑﻪ اﻳﻦ رآﻮرد ﺑﺴﻴﺎر ﺁﺳﺎن اﺳﺖ.‬ ‫ﻓﺎﻳﻞ هﺎي ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ ﺑﺮﺧﻼف ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ ﻣﻲ ﺗﻮاﻧﻨﺪ در ﻳﻚ زﻣـﺎن، هـﻢ ﻓﺎﻳـﻞ را‬ ‫ﺑﺨﻮاﻧﻨﺪ و هﻢ در ﺁن ﺑﻨﻮﻳﺴﻨﺪ.‬ ‫در ﻓﺎﻳﻞ هﺎي ﺗـﺼﺎدﻓﻲ اﻃﻼﻋـﺎت را ﻣـﻲ ﺗـﻮان در هـﺮ ﺟـﺎي ﻓﺎﻳـﻞ ﻧﻮﺷـﺖ ﺑـﺪون ﺁﻧﻜـﻪ هﻤﺠـﻮاري‬ ‫رآﻮردهﺎ از ﺑﻴﻦ ﺑﺮود ﻳﺎ ﻟﻄﻤﻪ اي ﺑﺨﻮرد.‬ ‫ﻓﺎﻳﻞ هﺎي ﺑﺎﻳﻨﺮي: اﻳﻨﮕﻮﻧﻪ ﻓﺎﻳﻞ هﺎ ﺷﺒﻴﻪ ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ هﺴﺘﻨﺪ.‬ ‫ﻣﺤﺘﻮﻳﺎت اﻳﻦ ﻓﺎﻳﻞ هﺎ ﻣﻲ ﺗﻮاﻧﺪ هﺮ ﭼﻴﺰي ﺑﺎﺷﺪ.‬ ‫آﺎراآﺘﺮ، ﻋﺪد ﻳﺎ ﺣﺘﻲ ﺗﺼﺎوﻳﺮ ﻣﻲ ﺗﻮاﻧﻨﺪ در ﻓﺎﻳﻞ هﺎي ﺑﺎﻳﻨﺮي ذﺧﻴﺮﻩ ﺷﻮﻧﺪ.‬ ‫در اﻳﻦ ﻧﻮع ﻓﺎﻳﻞ هﺎ، دادﻩ هﺎ ﺑﻪ ﺻﻮرت ﺑﺎﻳﻨﺮي ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫ﻣﺜﻼ ﻋﺪد ٦٢٤ ﻋﺪدي از ﻧﻮع ﺻﺤﻴﺢ اﺳﺖ و ﭼﻮن اﻋﺪاد ﺻﺤﻴﺢ دو ﺑﺎﻳﺖ از ﺣﺎﻓﻈـﻪ را اﺷـﻐﺎل ﻣـﻲ‬ ‫آﻨﻨﺪ ﭘﺲ ﻣﻴﺰان ﻓﻀﺎي اﺧﺘﺼﺎص ﻳﺎﻓﺘﻪ ﺑﻪ اﻳﻦ ﻋﺪد در اﻳﻦ ﻧﻮع ﻓﺎﻳﻞ، ٢ ﺑﺎﻳﺖ اﺳﺖ.‬ ‫اﻧﺠﺎم ﻋﻤﻠﻴﺎت ﺑﺮ روي ﻓﺎﻳﻞ هﺎ ﺑﺪون در ﻧﻈﺮ ﮔﺮﻓﺘﻦ ﻧﻮع ﺁﻧﻬﺎ، ﺑﻪ ﻃـﻮر آﻠـﻲ ﺷـﺎﻣﻞ ٣ ﻣﺮﺣﻠـﻪ ﻣـﻲ‬ ‫ﺑﺎﺷﺪ:‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٣٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 44.
    ‫ﺑﺎزآﺮدن ﻓﺎﻳﻞ: دراﻳﻦ ﻣﺮﺣﻠﻪ، ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﻣﻴـﺰان ﻣﻌﻴﻨـﻲ از ﺣﺎﻓﻈـﻪ را ﺑـﺮاي ﻧﮕﻬـﺪاري دادﻩ‬ ‫هﺎي ﻓﺎﻳﻞ آﻨﺎر ﻣﻲ ﮔﺬارد. اﮔﺮ ﻓﺎﻳﻞ وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ، اﺑﺘـﺪا ﺳـﺎﺧﺘﻪ ﺷـﺪﻩ و ﺳـﭙﺲ ﺑـﺎز ﻣـﻲ‬ ‫ﺷﻮد.‬ ‫ﺑﺮاي ﺑﺎزآﺮدن ﻳﺎ در ﺻﻮرت ﻟﺰوم، اﻳﺠﺎد ﻳﻚ ﻓﺎﻳﻞ از ﺗﺎﺑﻊ )(‪ FileOpen‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﭘﺮدازش ﻓﺎﻳﻞ: ﻳﻚ ﻓﺎﻳﻞ ﻣﻲ ﺗﻮاﻧـﺪ ﺑـﺮاي ﺧﻮاﻧـﺪن، ﻧﻮﺷـﺘﻦ و ﻳـﺎ ﺧﻮاﻧـﺪن-ﻧﻮﺷـﺘﻦ هﻤﺰﻣـﺎن دادﻩ‬ ‫هﺎﻳﺶ ﺑﺎز ﺷﻮد.‬ ‫دادﻩ هﺎﻳﻲ آﻪ ﺧﻮاﻧﺪﻩ ﻣﻲ ﺷﻮﻧﺪ، ﭘﺮدازش ﺷﺪﻩ و ﺳﭙﺲ در هﻤﺎن ﺟﺎي ﻗﺒﻠﻲ ﻳﺎ در ﻓﺎﻳﻞ دﻳﮕﺮي‬ ‫ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫ﺑﺴﺘﻦ ﻓﺎﻳﻞ: هﻨﮕﺎﻣﻲ آﻪ آﺎر ﺑﺎ ﻓﺎﻳﻞ ﺑﻪ اﺗﻤﺎم رﺳﻴﺪ ﺑﺎﻳﺪ ﺁن را ﺑﺴﺖ. هﻨﮕﺎﻣﻲ آﻪ ﻓﺎﻳـﻞ ﺑـﺴﺘﻪ‬ ‫ﺷﺪ، ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﻓﻀﺎي اﺧﺘﺼﺎص دادﻩ ﺷﺪﻩ ﺑﻪ ﻓﺎﻳﻞ را ﺑﻪ ﺣﺎﻓﻈﻪ اﺻﻠﻲ ﺑﺎز ﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺑﺮاي ﺑﺴﺘﻦ ﻳﻚ ﻓﺎﻳﻞ ﺑﺎز از ﺗﺎﺑﻊ )(‪ FileClose‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫)‪FreeFile(file_number‬‬ ‫هﺮ ﻓﺎﻳﻠﻲ آﻪ ﺑﺎز ﻣﻲ ﺷﻮد ﺑﺎﻳﺪ ﺷﻤﺎرﻩ اي ﺑﻪ ﺁن اﺧﺘﺼﺎص ﻳﺎﺑﺪ.‬ ‫اﮔﺮ ﺑﺮﻧﺎﻣﻪ ي ﺷﻤﺎ در ﻃﻮل دورﻩ آﺎري ﺧﻮد ﺗﻌﺪاد زﻳـﺎدي ﻓﺎﻳـﻞ را ﺑـﺎز ﻳـﺎ ﺑـﺴﺘﻪ ﻣـﻲ آﻨـﺪ، ﻣﻤﻜـﻦ‬ ‫ﻧﻴﺴﺖ آﻪ ﺷﻤﺎ هﻤﻴﺸﻪ ﺷﻤﺎرﻩ ﻓﺎﻳﻞ ﻳﺎ ﻓﺎﻳﻞ هﺎﻳﻲ را آﻪ هﻢ اآﻨﻮن ﺑﺎز هﺴﺘﻨﺪ ﺑﺪاﻧﻴﺪ.‬ ‫در ‪ ،VB‬ﺗﺎﺑﻊ )(‪ FreeFile‬ﺷﻤﺎرﻩ ﻓﺎﻳﻠﻲ ﺑﻌﺪي را آﻪ ﻗﺮار اﺳﺖ ﺑﺎز ﺷﻮد ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ هﻤﻴﺸﻪ ﺑﺎ ﺗﺎﺑﻊ )(‪ FileOpen‬ﺟﻬﺖ ﺑﺎزآﺮدن ﻳﻚ ﻓﺎﻳﻞ ﺑﻪ آﺎر ﻣﻲ رود.‬ ‫ﻧﻜﺘﻪ: ﺗﺎﺑﻊ )(‪ FreeFile‬را ﻧﻤﻲ ﺗﻮان ﺑﻪ ﻃﻮر ﻣﺴﺘﻘﻴﻢ در ﺗﺎﺑﻊ )(‪ OpenFile‬ﺑﻪ آﺎر ﺑﺮد.‬ ‫دﺳﺘﻮر زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)‪FileOpen(FreeFile(), ”C:MyFile.dat”,OpenMode.Input‬‬ ‫اﻳﻦ دﺳﺘﻮر از ﻧﻈﺮ ﻧﺤﻮي درﺳﺖ آﺎر ﻣﻲ آﻨﺪ اﻣﺎ ﺷﻤﺎرﻩ ﻓﺎﻳﻞ را در اﺧﺘﻴﺎرﺗـﺎن ﻗـﺮار ﻧﻤـﻲ دهـﺪ ﺗـﺎ‬ ‫ﺑﺘﻮاﻧﻴﺪ اﻋﻤﺎل ﺧﻮاﻧﺪن ﻳﺎ ﻧﻮﺷﺘﻦ را ﺑﺮ روي ﻓﺎﻳﻞ اﻧﺠﺎم دهﻴﺪ.‬ ‫دﺳﺘﻮر زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)(‪fNum =FreeFile‬‬ ‫)‪FileOpen(fNum, fileName‬‬ ‫ﺑﻌﺪ از اﺟﺮاي اﻳﻦ دو دﺳﺘﻮر، هﺮ ﻓﺮﻣﺎﻧﻲ آﻪ ﺑﺎ ﻓﺎﻳﻞ ﺳﺮوآﺎر داﺷﺘﻪ ﺑﺎﺷﺪ ﻣﻲ ﺗﻮاﻧﺪ ﺑـﺎ ﺁوردن ﻧـﺎم‬ ‫‪ fNum‬در ﺁرﮔﻮﻣﺎن ﻣﺮﺑﻮﻃﻪ ي ﺧﻮد، ﺑﻪ اﻳﻦ ﻓﺎﻳﻞ دﺳﺘﺮﺳﻲ داﺷﺘﻪ ﺑﺎﺷﺪ.‬ ‫هﻤﺎن ﻃﻮر آﻪ ﮔﻔﺘﻪ ﺷﺪ اﻳﻦ ﺗﺎﺑﻊ، ﺷﻤﺎرﻩ ﻓﺎﻳﻞ ﺑﻌﺪي را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ ﻣﮕﺮ اﻳﻨﻜﻪ اﻳﻦ ﺷﻤﺎرﻩ ﺑـﻪ‬ ‫ﻓﺎﻳﻠﻲ اﺧﺘﺼﺎص دادﻩ ﺷﺪﻩ ﺑﺎﺷﺪ. در اﻳﻨﺼﻮرت در ﺻﻮرت ﻓﺮاﺧﻮاﻧﻲ ﻣﺠﺪد اﻳﻦ ﺗﺎﺑﻊ، ﻋﺪدي ﻣﺸﺎﺑﻪ‬ ‫ﻓﺮاﺧﻮاﻧﻲ ﻗﺒﻠﻲ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل دﺳﺘﻮرات زﻳﺮ آﺎر ﻧﻤﻲ آﻨﻨﺪ:‬ ‫)(‪fNum1 =FreeFile‬‬ ‫)(‪fNum2 =FreeFile‬‬ ‫)1‪FileOpen(fNum1, file‬‬ ‫)2‪FileOpen(fNum2, file‬‬ ‫دﺳﺘﻮر دوم اﺷﺘﺒﺎﻩ اﺳﺖ ﭼﻮن هﺮ وﻗﺖ آـﻪ ﺗـﺎﺑﻊ )(‪ FreeFile‬ﺑـﺮاي ﺗﻌﻴـﻴﻦ ﺷـﻤﺎرﻩ ي ﻳـﻚ ﻓﺎﻳـﻞ‬ ‫ﺟﺪﻳﺪ ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ ﺷﻮد ﺑﺎﻳﺪ ﻣﻮرد اﺳﺘﻔﺎدﻩ ﻗﺮار ﺑﮕﻴﺮد و ﻧﻤﻲ ﺗﻮان ﻗﺒﻞ از ﺑﻪ آﺎرﮔﻴﺮي ﺁن دوﺑﺎرﻩ‬ ‫از هﻤﻴﻦ ﺗﺎﺑﻊ ﺟﻬﺖ اﻳﺠﺎد ﻳﻚ ﺷﻤﺎرﻩ ﺟﺪﻳﺪ اﺳﺘﻔﺎدﻩ آﺮد.‬ ‫ﭘﺲ دﺳﺘﻮرات ﻓﻮق را ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺻﻼح ﻣﻲ آﻨﻴﻢ:‬ ‫)(‪fNum1 =FreeFile‬‬ ‫)1‪FileOpen(fNum1, file‬‬ ‫)(‪fNum2 =FreeFile‬‬ ‫)2‪FileOpen(fNum, file‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٤٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 45.
    ‫)] ‪FileOpen(number,path,mode [,access][,share ][,recordLen‬‬ ‫ﺑﺮاي اﺳﺘﻔﺎدﻩ از ﻳﻚ ﻓﺎﻳﻞ، ﺑﺎﻳﺪ اﺑﺘﺪا ﺁن را ﺑﺎز ﻳﺎ در ﺻﻮرت ﻧﻴﺎز ﺁن را اﻳﺠﺎد آﻨﻴﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ FileOpen‬ﺑﺎ درﻳﺎﻓﺖ ﻣﻘﺎدﻳﺮي اﻳﻦ آﺎر را ﺑﺮاي ﺷﻤﺎ اﻧﺠﺎم ﻣﻲ دهﺪ.‬ ‫اﻳﻦ ﺗـﺎﺑﻊ، ﺟﺎﻧـﺸﻴﻦ دﺳـﺘﻮر ‪ Open‬در 0.6.‪ VB‬ﺷـﺪﻩ اﺳـﺖ. ﺗﻮﺟـﻪ داﺷـﺘﻪ ﺑﺎﺷـﻴﺪ آـﻪ دﺳـﺘﻮر‬ ‫‪ Open‬در ‪ VB.NET‬ﻗﺎﺑﻞ اﺳﺘﻔﺎدﻩ ﻧﻴﺴﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ path‬ﻣﺴﻴﺮ و ﻧﺎم ﻓﺎﻳﻠﻲ اﺳﺖ آﻪ ﺑﺎﻳﺪ ﺑﺎز ﺷﻮد و ﺁرﮔﻮﻣﺎن ‪ number‬ﺷـﻤﺎرﻩ اي اﺳـﺖ‬ ‫آﻪ ﺷﻤﺎ ﺑﻪ اﻳﻦ ﻓﺎﻳﻞ اﺧﺘﺼﺎص ﻣﻲ دهﻴﺪ )ﻣﻌﻤﻮﻻ ﺑﺎ ﺗﺎﺑﻊ )(‪.(FreeFile‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،mode‬ﻧﻮع ﻋﻤﻠﻴﺎﺗﻲ را آﻪ ﻗﺮار اﺳﺖ ﺑﺮ روي ﻓﺎﻳﻞ اﻧﺠﺎم ﺷـﻮد ﺗﻌﻴـﻴﻦ ﻣـﻲ آﻨـﺪ و ﻣـﻲ‬ ‫ﺗﻮاﻧﺪ ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ زﻳﺮ ﺑﺎﺷﺪ:‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ Mode‬در ﺗﺎﺑﻊ )(‪FileOpen‬‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻣﻘﺪار‬ ‫اﻳﻦ ﻣﻘﺪار ﺑﺮاي ﺑﺎزآﺮدن ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ آﻪ وﺟﻮد دارد ﺑﻪ آﺎر ﻣﻲ رود. اﮔﺮ ﻓﺎﻳـﻞ را ﺑـﺎ‬ ‫‪Input‬‬ ‫اﻳﻦ ﻣﻘﺪار ﺑﺎز آﻨﻴﻢ ﻓﻘﻂ ﻣﻲ ﺗﻮاﻧﻴﻢ اﻃﻼﻋﺎت را از ﺁن ﺑﺨﻮاﻧﻴﻢ. ﭼﻨﺎﻧﭽـﻪ ﻓـﺎﻳﻠﻲ آـﻪ‬ ‫ﻗﺒﻼ ﺑﺮ روي دﻳﺴﻚ وﺟـﻮد ﻧﺪاﺷـﺘﻪ و ﺑﺨـﻮاهﻴﻢ ﺑـﺎ ﻣـﺪ ‪ Input‬ﺑـﺎز آﻨـﻴﻢ، ﺧﻄـﺎﻳﻲ‬ ‫اﺗﻔﺎق ﻣﻲ اﻓﺘﺪ.‬ ‫اﻳ ـﻦ ﻣﻘ ـﺪار، ﻓﺎﻳ ـﻞ ﺗﺮﺗﻴﺒ ـﻲ را ﻃ ـﻮري ﺑ ـﺎز ﻣ ـﻲ آﻨ ـﺪ آ ـﻪ ﺑﺘ ـﻮان اﻃﻼﻋ ـﺎﺗﻲ را در ﺁن‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫‪Output‬‬ ‫ﻧﻮﺷﺖ. اﮔﺮ ﻓﺎﻳﻠﻲ آﻪ ﺑﺎ ﻣﺪ ‪ Output‬ﺑـﺎز ﻣـﻲ ﺷـﻮد وﺟـﻮد ﻧﺪاﺷـﺘﻪ ﺑﺎﺷـﺪ، ﺁن را‬ ‫اﻳﺠﺎد ﻣﻲ آﻨﺪ وﻟﻲ اﮔﺮ وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﺪ، اﻃﻼﻋﺎت ﻗﺒﻠﻲ ﺁن را از ﺑـﻴﻦ ﻣـﻲ ﺑـﺮد‬ ‫و ﺁن را ﺑﺮاي درﻳﺎﻓﺖ اﻃﻼﻋﺎت ﺟﺪﻳﺪ ﺁﻣﺎدﻩ ﻣﻲ آﻨﺪ. ﺑﻪ ﻃﻮر آﻠﻲ اﻳـﻦ ﻣﻘـﺪار ﻓﺎﻳـﻞ‬ ‫را در ﺣﺎﻟﺖ ﺧﺮوﺟﻲ ﺑﺎز ﻣﻲ آﻨﺪ ﻳﻌﻨﻲ ﻓﻘﻂ ﻣﻲ ﺗﻮان اﻃﻼﻋﺎت را ﺑـﻪ ﻓﺎﻳـﻞ اﺿـﺎﻓﻪ‬ ‫آﺮد.‬ ‫ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ آﻪ ﻗﺒﻼ وﺟـﻮد داﺷـﺘﻪ ﺑﺎﺷـﺪ و ﺑﺨـﻮاهﻴﻢ اﻃﻼﻋـﺎﺗﻲ زا ﺑـﻪ ﺁن اﺿـﺎﻓﻪ‬ ‫‪Append‬‬ ‫آﻨﻴﻢ، ﺑﺎﻳﺪ از اﻳﻦ ﻣﻘﺪار اﺳﺘﻔﺎدﻩ آﻨﻴﻢ. ﭼﻨﺎﻧﭽﻪ ﻓﺎﻳﻞ ﻗﺒﻼ وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷـﺪ، ﺁن‬ ‫را اﻳﺠﺎد ﻣﻲ آﻨﺪ.‬ ‫اﻳﻦ ﻣﻘﺪار، ﻓﺎﻳﻞ را ﺑﻪ ﺻﻮرت ﺑﺎﻳﻨﺮي ﺑﺎز ﻣﻲ آﻨﺪ. در ﺣﺎﻟﺖ ﺑﺎﻳﻨﺮي ﻣﻲ ﺗﻮان ﺑﻪ هـﺮ‬ ‫‪Binary‬‬ ‫ﻳﻚ از ﺑﺎﻳﺖ هﺎي ﻓﺎﻳﻞ دﺳﺘﺮﺳﻲ داﺷﺖ و ﻣﻲ ﺗﻮان ﻳﻚ ﺑﺎﻳﺖ را از ﻓﺎﻳـﻞ ﺧﻮاﻧـﺪ ﻳـﺎ‬ ‫در ﻓﺎﻳﻞ ﻧﻮﺷﺖ.‬ ‫اﻳﻦ ﻣﻘﺪار، ﻳﻚ ﻓﺎﻳﻞ را ﺑﻪ ﻃﻮر ﺗﺼﺎدﻓﻲ ﺑﺎز ﻣـﻲ آﻨـﺪ. در اﻳـﻦ ﺣﺎﻟـﺖ ﻣـﻲ ﺗـﻮان در‬ ‫‪Random‬‬ ‫ﻓﺎﻳﻞ ﻧﻮﺷﺖ ﻳﺎ از ﻓﺎﻳﻞ ﺧﻮاﻧﺪ.‬ ‫ﺳﻪ ﻣﻘﺪار اول ﺑﺎ ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒـﻲ، ﻣﻘـﺪار ‪ Random‬ﺑـﺎ ﻓﺎﻳـﻞ هـﺎي ﺑـﺎ دﺳﺘﺮﺳـﻲ ﺗـﺼﺎدﻓﻲ و‬ ‫ﻣﻘﺪار ‪ Binary‬ﺑﺮاي ﻓﺎﻳﻞ هﺎي ﺑﺎﻳﻨﺮي ﺑﻪ آﺎر ﻣﻲ روﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ access‬ﻧﻮع دﺳﺘﺮﺳﻲ ﺑﻪ ﻓﺎﻳﻞ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ. ﻳﻌﻨﻲ ﻓﺎﻳﻞ ﺑﺮاي ﺧﻮاﻧـﺪن ﻳـﺎ‬ ‫ﻧﻮﺷﺘﻦ ﻳﺎ هﺮ دو ﻋﻤﻞ ﺑﺎز ﺷﻮد.‬ ‫ﻣﻘﺎدﻳﺮي آﻪ اﻳﻦ ﺁرﮔﻮﻣﺎن ﻣﻲ ﺗﻮاﻧﺪ ﺑﭙﺬﻳﺮد در ﺟﺪول زﻳﺮ ﺁﻣﺪﻩ اﺳﺖ:‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ access‬در ﺗﺎﺑﻊ )(‪FileOpen‬‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻣﻘﺪار‬ ‫ﻓﺎﻳﻞ را در ﺣﺎﻟﺖ ورودي ﺑﺎز ﻣﻲ آﻨﺪ. ﻳﻌﻨﻲ ﻓﻘﻂ ﻣﻲ ﺗﻮان ﻓﺎﻳﻞ را ﺧﻮاﻧﺪ.‬ ‫‪Read‬‬ ‫ﻓﺎﻳﻞ را در ﺧﺎﻟﺖ ﺧﺮوﺟﻲ ﺑﺎز ﻣﻲ آﻨﺪ. ﻳﻌﻨﻲ ﻓﻘﻂ ﻣﻲ ﺗﻮان در ﻓﺎﻳﻞ ﻧﻮﺷﺖ.‬ ‫‪Write‬‬ ‫ﻓﺎﻳﻞ را در ﺣﺎﻟﺖ ورودي-ﺧﺮوﺟﻲ ﺑﺎز ﻣﻲ آﻨﺪ. ﻳﻌﻨﻲ هﻢ ﻣﻲ ﺗﻮان اﻃﻼﻋـﺎت را‬ ‫‪ReadWrite‬‬ ‫از ﻓﺎﻳﻞ ﺧﻮاﻧﺪ و هﻢ در ﻓﺎﻳﻞ ﻧﻮﺷﺖ.‬ ‫اﻳﻦ ﺁرﮔﻮﻣﺎن ﺑﻴـﺸﺘﺮ ﺑـﺮاي ﺑـﺎﻻ ﺑـﺮدن اﻣﻨﻴـﺖ آـﺎر ﺑـﺎ ﻓﺎﻳـﻞ ﺑـﻪ آـﺎر ﻣـﻲ رود و ﺿـﺮورت ﭼﻨـﺪاﻧﻲ در‬ ‫اﺳﺘﻔﺎدﻩ از ﺁن وﺟﻮد ﻧﺪارد. ﻣﺜﻼ ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ ﻣﻲ ﺗﻮاﻧﻨﺪ ﺑﺮاي ﻓﻘﻂ ﺧﻮاﻧـﺪن ﻳـﺎ ﻓﻘـﻂ ﻧﻮﺷـﺘﻦ‬ ‫ﺑﺎز ﺷﻮﻧﺪ ﻧﻪ هﺮ دو. ﭘﺲ اﺳﺘﻔﺎدﻩ از ﺁرﮔﻮﻣﺎن ‪ ReadWrite‬اﻳﻦ ﺁرﮔﻮﻣـﺎن در هﻨﮕـﺎم ﺑـﺎز آـﺮدن ﻳـﻚ‬ ‫ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ ﺑﻲ اﺛﺮ اﺳﺖ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٥٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 46.
    ‫وﻟﻲ ﺟﻬﺖ ﺑﺎﻻﺑﺮدن ﺿﺮﻳﺐ اﻣﻨﻴﺖ اﺳﺘﻔﺎدﻩ از ﻓﺎﻳﻞ، هﻨﮕﺎﻣﻲ آﻪ ﻓﺎﻳـﻞ را در هـﺮ ﺣـﺎﻟﺘﻲ ﺑـﺎز ﻣـﻲ‬ ‫آﻨﻴﺪ، ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻧﻮع ﻓﺎﻳﻞ اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺁرﮔﻮﻣﺎن ﻧﻴﺰ ﺿﺮري ﻧﺪارد.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،share‬ﻧﺤﻮﻩ ﻋﻜﺲ اﻟﻌﻤﻞ ﻓﺎﻳﻠﻲ آﻪ ﺗﻮﺳﻂ ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﺑﺎز ﺷﺪﻩ اﺳـﺖ را ﺑـﻪ‬ ‫ﺑﺮﻧﺎﻣﻪ هﺎي دﻳﮕﺮ وﻳﻨﺪوز، در هﻤﺎن زﻣﺎن آﻪ ﺷﻤﺎ ﻓﺎﻳﻞ را ﺑﺎز آﺮدﻩ اﻳﺪ ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ.‬ ‫ﺑﻪ ﻋﺒﺎرت دﻳﮕﺮ ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻧﺤﻮﻩ دﺳﺘﺮﺳﻲ ﺑﺮﻧﺎﻣﻪ هﺎي دﻳﮕﺮ را ﺑﻪ ﻓﺎﻳﻠﻲ آﻪ ﺷﻤﺎ ﺑـﺎز آـﺮدﻩ‬ ‫و در ﺣﺎل اﺳﺘﻔﺎدﻩ از ﺁن هﺴﺘﻴﺪ ﺗﻌﻴﻴﻦ آﻨﻴﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ share‬ﻣﻲ ﺗﻮاﻧﺪ ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ زﻳﺮ را ﺑﭙﺬﻳﺮد:‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ share‬در ﺗﺎﺑﻊ )(‪FileOpen‬‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻣﻘﺪار‬ ‫ﺑﺮﻧﺎﻣﻪ هﺎي دﻳﮕﺮ ﻣﻲ ﺗﻮاﻧﻨﺪ از ﻓﺎﻳﻞ اﺳﺘﻔﺎدﻩ آﻨﻨﺪ.‬ ‫‪Shared‬‬ ‫ﺑﺮﻧﺎﻣﻪ هﺎي دﻳﮕﺮ ﻓﻘﻂ در ﺻﻮرﺗﻲ ﻣﺠﺎز ﺑﻪ اﺳﺘﻔﺎدﻩ از ﻓﺎﻳﻞ هـﺴﺘﻨﺪ آـﻪ‬ ‫‪LockRead‬‬ ‫ﺁن را ﻓﻘﻂ ﺑﺮاي ﺧﻮاﻧﺪن ﺑﺎز آﺮدﻩ ﺑﺎﺷﻨﺪ.‬ ‫ﺑﺮﻧﺎﻣﻪ هﺎي دﻳﮕﺮ ﻓﻘﻂ در ﺻﻮرﺗﻲ ﻣﺠﺎز ﺑﻪ اﺳﺘﻔﺎدﻩ از ﻓﺎﻳﻞ هـﺴﺘﻨﺪ آـﻪ‬ ‫‪LockWrite‬‬ ‫ﺁن را ﻓﻘﻂ ﺑﺮاي ﻧﻮﺷﺘﻦ ﺑﺎز آﺮدﻩ ﺑﺎﺷﻨﺪ.‬ ‫ﺑﺮﻧﺎﻣﻪ هﺎي دﻳﮕﺮ ﻣﺠﺎز ﺑﻪ اﺳﺘﻔﺎدﻩ از ﻓﺎﻳﻞ ﻧﻴﺴﺘﻨﺪ‬ ‫‪LockReadWrite‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ share‬ﻳﻚ ﭘﺎراﻣﺘﺮ ﺑﺴﻴﺎر ﻣﻬﻢ ﺑﺮاي ﺑﺮﻧﺎﻣﻪ هـﺎﻳﻲ اﺳـﺖ آـﻪ ﺗﺤـﺖ ﺷـﺒﻜﻪ ﻧﻮﺷـﺘﻪ ﻣـﻲ‬ ‫ﺷﻮﻧﺪ. ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل دو آﺎرﺑﺮ ﺑﻪ ﻃﻮر هﻤﺰﻣﺎن ﻗﺼﺪ ﻧﻮﺷﺘﻦ در ﻳﻚ ﻓﺎﻳﻞ را دارﻧﺪ.‬ ‫و اﻣﺎ ﺁﺧﺮﻳﻦ ﺁرﮔﻮﻣﺎن ﻳﻌﻨﻲ ﺁرﮔﻮﻣﺎن اﺧﺘﻴـﺎري ‪ recordlen‬آـﻪ ﻓﻘـﻂ در ﻓﺎﻳـﻞ هـﺎي ﺑـﺎ دﺳﺘﺮﺳـﻲ‬ ‫ﺗﺼﺎدﻓﻲ آﺎرﺑﺮد دارد.‬ ‫اﮔﺮ ﻓﺎﻳﻠﻲ آﻪ ﻗﺼﺪ ﺑﺎزآﺮدن ﺁن را دارﻳﺪ از اﻳﻦ ﻧﻮع ﺑﺎﺷﺪ ﺑﺎﻳﺪ ﻃﻮل هﺮ رآﻮرد ﻓﺎﻳﻞ را آﻪ ﺑـﺮ ﺣـﺴﺐ‬ ‫ﺑﺎﻳﺖ اﺳﺖ ﺑﻪ وﺳﻴﻠﻪ اﻳﻦ ﺁرﮔﻮﻣﺎن ﻣﺸﺨﺺ آﻨﻴﺪ.‬ ‫هﻨﮕﺎﻣﻲ آﻪ در وﻳﮋوال ﺑﻴﺴﻴﻚ ﻓﺎﻳﻠﻲ ﺑﺎ دﺳﺘﺮﺳـﻲ ﺗـﺼﺎدﻓﻲ اﻳﺠـﺎد ﻣـﻲ آﻨﻴـﺪ، هـﻴﭻ اﻃﻼﻋـﺎﺗﻲ‬ ‫راﺟﻊ ﺑﻪ ﻃﻮل رآﻮرد ﻳﺎ ﺳﺎﺧﺘﺎر ﺁن در ﻓﺎﻳﻞ ذﺧﻴﺮﻩ ﻧﻤﻲ ﺷﻮد.‬ ‫اﻳﻦ ﻣﻮرد را ﻗﺒﻞ از ﺑﺎزآﺮدن اﻳﻦ ﻧﻮع ﻓﺎﻳﻞ هﺎ ﺑﺎﻳﺪ ﺑﺪاﻧﻴﺪ.‬ ‫ﻃـﻮل رآـﻮرد، ﻣﺠﻤـﻮع ﺑﺎﻳـﺖ هـﺎي ﺗﻤـﺎﻣﻲ ﻓﻴﻠـﺪهﺎي ﺁن ﻓﺎﻳـﻞ اﺳـﺖ آـﻪ ﻣـﻲ ﺗﻮاﻧﻴـﺪ ﺑـﺎ دﺳـﺘﻮر‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫)‪ Len(record‬ﺁن را ﻣﺤﺎﺳﺒﻪ آﻨﻴﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ record‬در اﻳﻦ دﺳﺘﻮر ﻧﺎم ﺳﺎﺧﺘﺎري اﺳﺖ آﻪ ﺑﺮاي ﺑﺎزآﺮدن ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ ﺑـﻪ آـﺎر ﺑـﺮدﻩ‬ ‫اﻳﺪ.‬ ‫دﺳﺘﻮر زﻳﺮ ﻓﺎﻳﻞ ‪ C:samplesvbcust.dat‬را آﻪ ﻳـﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ اﺳـﺖ ﺑـﺎ اﺧﺘـﺼﺎص دادن‬ ‫ﻋﺪدي آﻪ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ FreeFile‬ﺑﻪ دﺳﺖ ﺁوردﻩ، در ﺣﺎﻟﺖ ورودي-ﺧﺮوﺟﻲ ﺑﺎز ﻣﻲ آﻨﺪ:‬ ‫)(‪Dim Fnum As Integer =FreeFile‬‬ ‫)‪FileOpen(Fnum, “c:samples vb cust.dat ”, OpenMode.Output, OpenAccess.ReadWrite‬‬ ‫)‪FileClose(file_number‬‬ ‫ﭘﺲ از اﻳﻨﻜﻪ آﺎر ﺑﺎ ﻓﺎﻳﻞ ﺗﻤﺎم ﺷﺪ، ﺑﺎﻳﺪ ﺁن را ﺑﺴﺖ.‬ ‫ﺗﺎﺑﻊ )(‪ FileClose‬ﻓﺎﻳﻠﻲ را آـﻪ ﺷـﻤﺎرﻩ ي ﺁن ﺑـﻪ وﺳـﻴﻠﻪ ي ﺁرﮔﻮﻣـﺎن ‪ file_number‬ﻣـﺸﺨﺺ‬ ‫ﺷﺪﻩ ﻣﻲ ﺑﻨﺪد.‬ ‫دﺳﺘﻮر زﻳﺮ، ﻓﺎﻳﻠﻲ را آﻪ ﺷﻤﺎرﻩ ي ﺁن در ﻋﺒﺎرت 1‪ fNum‬وﺟﻮد دارد ﻣﻲ ﺑﻨﺪد.‬ ‫)1‪FileClose(fNum‬‬ ‫)(‪Reset‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ در ﺣﻘﻴﻘﺖ آﺎر ﺷﻤﺎ را در ﺑﺴﺘﻦ ﻓﺎﻳﻞ هﺎ ﺑﺴﻴﺎر ﺁﺳﺎﻧﺘﺮ ﻣﻲ آﻨﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺗﻤﺎﻣﻲ ﻓﺎﻳﻞ هﺎﻳﻲ را آﻪ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ FileOpen‬در ﺑﺮﻧﺎﻣـﻪ ﺷـﻤﺎ ﺑـﺎز ﺷـﺪﻩ اﻧـﺪ‬ ‫ﻣﻲ ﺑﻨﺪد.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٦٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 47.
    ‫)‪EOF(file_number) , LOF(file_number‬‬ ‫اﻳﻦ دو ﺗﺎﺑﻊ ﻣﻌﻤﻮﻻ در ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ ﻓﺎﻳﻞ هﺎ ﺳﺮ و آﺎر دارﻧﺪ ﺑﺴﻴﺎر ﺑﻪ آﺎر ﻣﻲ روﻧﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ EOF‬ﺑﺮاي ﺗﺴﺖ ﺷﺮط ﭘﺎﻳﺎن ﻓﺎﻳﻞ ﺑﻪ آـﺎر ﻣـﻲ رود. اﻳـﻦ ﺗـﺎﺑﻊ ﻓـﺎﻳﻠﻲ را آـﻪ ﺷـﻤﺎرﻩ ﺁن ﺑـﻪ‬ ‫وﺳﻴﻠﻪ ﺁرﮔﻮﻣﺎن ‪ file_number‬ﻣﺸﺨﺺ ﺷﺪﻩ ﭼﻚ ﻣﻲ آﻨﺪ و ﭼﻨﺎﻧﭽﻪ اﺷﺎرﻩ ﮔﺮ ﻓﺎﻳﻞ ﺑﻪ اﻧﺘﻬـﺎي‬ ‫ﺁن رﺳﻴﺪﻩ ﺑﺎﺷﺪ، اﻳﻦ ﺗﺎﺑﻊ ﻣﻘﺪار ‪ True‬وﮔﺮﻧﻪ ﻣﻘﺪار ‪ False‬را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ ،LOF‬اﻧﺪازﻩ ﻳﻚ ﻓﺎﻳﻞ ﺑﺎز را آـﻪ ﺷـﻤﺎرﻩ ﺁن ﺑـﻪ وﺳـﻴﻠﻪ ﺁرﮔﻮﻣـﺎن ‪ file_number‬ﻣـﺸﺨﺺ‬ ‫ﺷﺪﻩ اﺳﺖ ﺑﺮ ﺣﺴﺐ ﺑﺎﻳﺖ ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺷﺒﻪ آﺪ زﻳﺮ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ EOF‬و ﻳﻚ ﺣﻠﻘﻪ ﺗﻜﺮار، ﭘﺎﻳﺎن ﻳﻚ ﻓﺎﻳﻞ را ﭼﻚ ﻣﻲ آﻨﺪ:‬ ‫}رﻓﺘﻦ ﺑﻪ اوﻟﻴﻦ رآﻮرد ﻓﺎﻳﻞ{‬ ‫)‪While Not EOF(fNum‬‬ ‫}ﭘﺮدازش رآﻮرد ﺟﺎري{‬ ‫}رﻓﺘﻦ ﺑﻪ رآﻮرد ﺑﻌﺪ{‬ ‫‪End While‬‬ ‫ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ LOF‬ﻗﺎدر ﺑﻪ ﻣﺤﺎﺳﺒﻪ ي ﺗﻌﺪاد رآﻮرد هﺎي ﻳﻚ ﻓﺎﻳﻞ ﺑﺎ دﺳﺘﺮﺳـﻲ ﺗـﺼﺎدﻓﻲ‬ ‫هﺴﺘﻴﺪ. دﺳﺘﻮر زﻳﺮ اﻳﻦ آﺎر را ﺑﺮاي ﻣﺎ اﻧﺠﺎم ﻣﻲ دهﺪ:‬ ‫)‪Rec_Length =LOF(file_number) / Len(record‬‬ ‫)‪Print (file_number,output_list) , PrintLine(file_number,output_list‬‬ ‫ﺑﺮاي ﻧﻮﺷﺘﻦ در ﻳﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ آـﻪ ﺑـﻪ ﺻـﻮرت ‪ Output‬ﻳـﺎ ‪ Append‬ﺑـﺎز ﺷـﺪﻩ اﺳـﺖ از ﺗـﺎﺑﻊ‬ ‫)(‪ Print‬اﺳﺘﻔﺎدﻩ ﻣﻲ آﻨﻴﻢ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،file_number‬ﺷﻤﺎرﻩ ﻓﺎﻳﻠﻲ اﺳﺖ آﻪ ﻗﺒﻼ ﺑﺎ ﻳﻜﻲ از دو ﺣﺎﻟﺖ ﺑـﺎﻻ ﺑـﺎز ﺷـﺪﻩ اﺳـﺖ و‬ ‫ﺁرﮔﻮﻣﺎن ‪ output_list‬ﻧﻴﺰ ﻳﻚ ﺁراﻳﻪ ي ﭘـﺎراﻣﺘﺮي اﺳـﺖ، ﻳﻌﻨـﻲ ﻣﻘـﺎدﻳﺮ ﻳـﺎ ﻣﺘﻐﻴﺮهـﺎي ﻣﻘـﺪاردهﻲ‬ ‫ﺷﺪﻩ اي آﻪ ﺑﺎﻳﺪ در ﻓﺎﻳﻞ ﻧﻮﺷﺘﻪ ﺷﻮﻧﺪ.‬ ‫ﻧﻜﺘـﻪ: ﻣﻨﻈـﻮر از ﺁراﻳـﻪ ي ﭘـﺎراﻣﺘﺮي در ‪ ،VB‬ﺁرﮔﻮﻣـﺎﻧﻲ اﺳـﺖ آـﻪ ﻣـﻲ ﺗﻮاﻧـﺪ ﻣﻘـﺎدﻳﺮ ﻧﺎﻣﺤـﺪودي‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ﺑﭙﺬﻳﺮد. اﻳﻦ ﻣﻘﺎدﻳﺮ ﺑﺎ اﺳﺘﻔﺎدﻩ از آﺎراآﺘﺮ ),( از هﻢ ﺟﺪا ﻣﻲ ﺷﻮﻧﺪ.‬ ‫دﺳﺘﻮر زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫)333.333,”‪Print(fNum, var1, var2, “My VB World‬‬ ‫اﻳﻦ دﺳﺘﻮر، ٤ ﻣﻘﺪار ﺷﺎﻣﻞ ﻣﻘﺪار ٢ ﻣﺘﻐﻴﺮ، ﻳﻚ ﻣﻘﺪار رﺷﺘﻪ اي و ﻳـﻚ ﻣﻘـﺪار ﻋـﺪدي را در ﻓـﺎﻳﻠﻲ‬ ‫آﻪ ﺷﻤﺎرﻩ ﺁن در ﻋﺒﺎرت ‪ fNum‬وﺟﻮد دارد ذﺧﻴﺮﻩ ﻣﻲ آﻨﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ Print‬دادﻩ هﺎ را در ﺧﻄـﻮط ﻣﺠـﺰا ذﺧﻴـﺮﻩ ﻧﻤـﻲ آﻨـﺪ ﻳﻌﻨـﻲ اﻳﻨﻄـﻮر ﻧﻴـﺴﺖ آـﻪ ﺑـﺎ هـﺮ ﺑـﺎر‬ ‫ﻓﺮاﺧﻮاﻧﻲ اﻳﻦ ﺗﺎﺑﻊ، دادﻩ هﺎ در ﺧﻂ ﺑﻌﺪي ﻓﺎﻳﻞ ذﺧﻴﺮﻩ ﺷﻮﻧﺪ ﺑﻠﻜﻪ ﭘﺸﺖ ﺳﺮ هـﻢ و ﺑـﺪون ﻓﺎﺻـﻠﻪ‬ ‫ﻗﺮار ﺧﻮاهﻨﺪ ﮔﺮﻓﺖ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل، دﺳﺘﻮر زﻳﺮ ﻓﻘﻂ ﻳﻚ ﺧﻂ ﻣﺘﻨﻲ در ﻓﺎﻳﻠﻲ آﻪ ﺷﻤﺎرﻩ ﺁن در ‪ fNum‬وﺟـﻮد دارد ﻣـﻲ‬ ‫ﻧﻮﻳﺴﺪ:‬ ‫)" ‪Print(fNum, "This is the first half of the line‬‬ ‫)".‪Print(fNum, "and this is the second half of the same line‬‬ ‫ﺗﺎﺑﻊ )(‪ PrintLine‬هﻤﺎن آﺎري را اﻧﺠﺎم ﻣﻲ دهﺪ آﻪ ﺗﺎﺑﻊ )(‪ Print‬اﻧﺠﺎم ﻣﻲ دهﺪ ﺑـﺎ اﻳـﻦ ﺗﻔـﺎوت‬ ‫آﻪ ﺑﺎ هﺮ ﺑﺎر ﻓﺮاﺧﻮاﻧﻲ، دادﻩ را در ﺧﻄﻮط ﻣﺠﺰا ﻗﺮار ﻣﻲ دهـﺪ هﻤﺎﻧﻨـﺪ دﺳـﺘﻮر ‪ WriteLn‬در زﺑـﺎن‬ ‫ﭘﺎﺳﻜﺎل آﻪ اﻃﻼﻋﺎت را در ﺧﻄﻮط ﺟﺪا، ذﺧﻴﺮﻩ ﻣﻲ آﻨﺪ ﻳﺎ ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﺑﺮاي ﺧﻮاﻧﺪن دادﻩ هﺎﻳﻲ آﻪ ﺑﺎ ﺗﺎﺑﻊ )(‪ Print‬در ﻓﺎﻳـﻞ ذﺧﻴـﺮﻩ ﺷـﺪﻩ اﻧـﺪ از ﺗﻮاﺑـﻊ )(‪ LineInput‬و‬ ‫)(‪ Input‬اﺳﺘﻔﺎدﻩ ﻣﻲ آﻨﻴﻢ.‬ ‫ﺗﺎﺑﻊ )(‪ Print‬ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﺑﻴﻦ ﻓﻴﻠﺪهﺎي ﻣﺨﺘﻠﻒ در ﻳﻚ ﻓﺎﻳﻞ ﻓﺎﺻﻠﻪ اي ﻗﺮار ﻧﻤﻲ دهﺪ.‬ ‫ﺑﺮاي ﻗﺎﻟﺐ دهﻲ ﺑﻪ ﻓﻴﻠﺪهﺎﻳﻲ آﻪ در هﺮ ﺧﻂ ﻓﺎﻳﻞ ﻣﺘﻨﻲ ذﺧﻴﺮﻩ ﻣـﻲ ﺷـﻮﻧﺪ ﻣـﻲ ﺗﻮاﻧﻴـﺪ از آﻠﻤـﻪ‬ ‫آﻠﻴﺪي )‪ (Tab‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ ﺗﺎ ‪ VB‬در هﻨﮕﺎم ذﺧﻴـﺮﻩ دادﻩ هـﺎ در ﻓﺎﻳـﻞ، ﺑـﻴﻦ ﻓﻴﻠـﺪ هـﺎي ﻣﺨﺘﻠـﻒ‬ ‫ﻓﺎﺻﻠﻪ ﻗﺮار دهﺪ.‬ ‫هﻤﭽﻨﻴﻦ ﺧﻮد ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺮاي اﻳﻦ ﻓﺎﺻﻠﻪ ﻣﻘﺪاري ﺗﻌﻴﻴﻦ آﻨﻴﺪ. ﻣﺜﻼ: )21(‪Tab‬‬ ‫ﻣﺜﺎل زﻳﺮ ﻳﻚ ﻓﺎﻳﻞ ﻣﺘﻨﻲ را ﺳﺎﺧﺘﻪ و ﻣﻘﺪاري دادﻩ را در ﺁن ذﺧﻴﺮﻩ ﻣﻲ آﻨﺪ:‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٧٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 48.
    ‫‪On Error ResumeNext‬‬ ‫)” ‪Kill(“c:test.txt‬‬ ‫)(‪Dim fNum As Integer =FreeFile‬‬ ‫)‪FileOpen(fNum, “c:test.txt”, OpenMode.Output‬‬ ‫)33 ,)54(‪PrintLine(fNum, “Behrouz”, TAB(12), “Rad”, TAB(25), “Manager”, TAB‬‬ ‫)82 ,)54(‪PrintLine(fNum, “sina”, TAB(12), “ahmadi”, TAB(25), “Programmer”, TAB‬‬ ‫)14 ,)54(‪PrintLine(fNum, “arvin”, TAB(12), “sanaei”, TAB(25), “Engineer”, TAB‬‬ ‫)52 ,)54(‪PrintLine(fNum, “pedram”, TAB(12), “amiri”, TAB(25), “Administrator”, TAB‬‬ ‫)”*************************“ ,‪PrintLine(fNum‬‬ ‫)3 ,‪PrintLine(fNum, “Behrouz”, TAB, “Rad”, TAB, “Manager”, TAB‬‬ ‫)82 ,‪PrintLine(fNum, “sina”, TAB, “ahmadi”, TAB, “Programmer”, TAB‬‬ ‫)14 ,‪PrintLine(fNum, “arvin”, TAB, “sanaei”, TAB, “Engineer” , TAB‬‬ ‫)52 ,‪PrintLine(fNum, “pedram”, TAB, “amiri”, TAB, “Administrator”, TAB‬‬ ‫)‪FileClose(fNum‬‬ ‫ﺧﺮوﺟﻲ دﺳﺘﻮرات ﺑﺎﻻ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺧﻮاهﺪ ﺷﺪ:‬ ‫‪Behrouz‬‬ ‫‪Rad‬‬ ‫‪Manager‬‬ ‫33‬ ‫‪sina‬‬ ‫‪ahmadi‬‬ ‫‪Programmer‬‬ ‫82‬ ‫‪arvin‬‬ ‫‪sanaei‬‬ ‫‪Engineer‬‬ ‫14‬ ‫‪pedram‬‬ ‫‪amiri‬‬ ‫‪Administrator‬‬ ‫52‬ ‫*************************‬ ‫‪Behrouz‬‬ ‫‪Rad‬‬ ‫‪Manager‬‬ ‫33‬ ‫‪sina‬‬ ‫‪ahmadi‬‬ ‫‪Programmer‬‬ ‫82‬ ‫‪arvin‬‬ ‫‪sanaei‬‬ ‫‪Engineer‬‬ ‫14‬ ‫‪pedram‬‬ ‫‪amiri‬‬ ‫‪Administrator‬‬ ‫52‬ ‫)‪Input(file_number,var‬‬ ‫ﺑﺪﻳﻬﻲ اﺳﺖ آﻪ ﭘﺲ از ﻧﻮﺷﺘﻦ در ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒـﻲ، ﺑﺎﻳـﺪ ﺑﺘـﻮان اﻃﻼﻋـﺎت را از ﺁن ﺧﻮاﻧـﺪ و ﭘـﺮدازش‬ ‫آﺮد. ﺑﺮاي ﺧﻮاﻧﺪن اﻃﻼﻋﺎت از ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ، ﺑﺎﻳﺪ ﺁن را ﺑﻪ ﺻﻮرت ‪ Input‬ﺑﺎز آﺮد.‬ ‫ﺗﺎﺑﻊ )(‪ Input‬دادﻩ هﺎي ﻳﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ را ﺧﻮاﻧـﺪﻩ و ﺁﻧﻬـﺎ را در ﻣﺘﻐﻴـﺮي آـﻪ ﺑـﻪ ﻋﻨـﻮان دوﻣـﻴﻦ‬ ‫ﺁرﮔﻮﻣﺎن اﻳﻦ ﺗﺎﺑﻊ وﺟﻮد دارد ﻳﻌﻨﻲ ‪ var‬ﻣﻲ رﻳﺰد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ file_number‬ﺷﻤﺎرﻩ ﻓﺎﻳﻠﻲ اﺳـﺖ آـﻪ ﺑـﻪ ﺻـﻮرت ‪ Input‬ﺑـﺎز ﺷـﺪﻩ اﺳـﺖ و ﺁرﮔﻮﻣـﺎن‬ ‫‪ ،var‬ﻳـﻚ ﺁراﻳـﻪ ﭘـﺎراﻣﺘﺮي اﺳـﺖ آـﻪ ﺷـﺎﻣﻞ اﺳـﺎﻣﻲ ﻓﻴﻠـﺪهﺎ ﻳـﺎ ﻟﻴـﺴﺘﻲ از ﻣﺘﻐﻴﺮهـﺎ اﺳـﺖ آـﻪ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ‬ ‫ـ‬ ‫اﻃﻼﻋﺎت ﺧﻮاﻧﺪﻩ ﺷﺪﻩ در ﺁﻧﻬﺎ ﻗﺮار ﻣﻲ ﮔﻴﺮد.‬ ‫در اﻳﻦ دﺳﺘﻮر، اﮔﺮ هﻨﮕﺎم ﺧﻮاﻧﺪن ﻓﺎﻳﻞ ﺗﻌﺪاد ﻓﻴﻠﺪهﺎﻳﻲ آﻪ ﺷﻤﺎ ﻧﺎم ﺁﻧﻬﺎ را در ﺁرﮔﻮﻣﺎن ‪ var‬ﻣـﻲ‬ ‫ﺁورﻳﺪ از ﺗﻌﺪاد ﻓﻴﻠﺪهﺎي ﻓﺎﻳﻞ آﻤﺘﺮ ﺑﺎﺷﺪ، ﻓﻴﻠـﺪهﺎي ﺑﻌـﺪي در ﻓﺮاﺧـﻮاﻧﻲ ﺑﻌـﺪي ﻓﺮﻣـﺎن )(‪Input‬‬ ‫ﻧﻤﺎﻳﺶ دادﻩ ﻣﻲ ﺷﻮﻧﺪ. وﻟﻲ ﭼﻨﺎﻧﭽﻪ ﺗﻌﺪاد ﻓﻴﻠﺪهﺎﻳﻲ آﻪ ﻧﺎم ﺁﻧﻬﺎ در ﺁرﮔﻮﻣﺎن ‪ var‬ﻣﻲ ﻧﻮﻳـﺴﻴﺪ،‬ ‫ﺑﻴﺸﺘﺮ از ﺗﻌﺪاد ﻓﻴﻠﺪهﺎي ﻳﻚ رآﻮرد ﻓﺎﻳﻞ ﺑﺎﺷﺪ، ﺑـﻪ ﺗﻌـﺪاد ﻻزم از رآﻮردهـﺎي ﺑﻌـﺪي ﺧﻮاﻧـﺪﻩ ﻣـﻲ‬ ‫ﺷﻮﻧﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل، دﺳﺘﻮرات زﻳﺮ ﻳﻚ ﻣﻘﺪار ﻋﺪدي و ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ را از ﻓـﺎﻳﻠﻲ آـﻪ ﺑـﺎز ﺷـﺪﻩ‬ ‫اﺳﺖ ﻣﻲ ﺧﻮاﻧﻨﺪ:‬ ‫‪Dim numVal As Long,DateVal As Date‬‬ ‫)‪Input(1,numVal‬‬ ‫)‪Input(1,DateVal‬‬ ‫)‪LineInput(file_number‬‬ ‫ﭘﻴﺸﻨﻬﺎد ﻣﻲ آﻨﻢ ﺑﺮاي ﺧﻮاﻧﺪن ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ از اﻳﻦ ﺗﺎﺑﻊ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ file_number‬ﺷﻤﺎرﻩ ﻓﺎﻳـﻞ ﺑـﺎز ﺷـﺪﻩ اﺳـﺖ و اﻳـﻦ ﺗـﺎﺑﻊ ﻳـﻚ ﺳـﻄﺮ از ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ را‬ ‫ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ، در اوﻟﻴﻦ ﺑﺎر ﻓﺮاﺧﻮاﻧﻲ، اوﻟـﻴﻦ ﺧـﻂ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ را ﺑﺮﮔـﺸﺖ ﻣـﻲ دهـﺪ و در ﻓﺮاﺧـﻮاﻧﻲ‬ ‫ﺑﻌﺪي دوﻣﻴﻦ ﺧﻂ و ﺑﻪ هﻤﻴﻦ ﻣﻨﻮال.‬ ‫دﺳﺘﻮرات زﻳﺮ ﺳﻄﺮهﺎي اول و دوم ﻳﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ را در ﻣﺘﻐﻴﺮهـﺎي 1‪ Line‬و 2‪ Line‬ﻗـﺮار ﻣـﻲ‬ ‫دهﻨﺪ.‬ ‫)‪Line1 =LineInput(fNum‬‬ ‫)‪Line2 =LineInput(fNum‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٨٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 49.
    ‫ﺑﺮاي ذﺧﻴﺮﻩ ﺳﺎزيﻣﺘﻦ هﺎي ﺳﺎدﻩ در ﻳﻚ ﻓﺎﻳﻞ، ﻳﻚ ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ درﺳﺖ آﻨﻴـﺪ و دادﻩ هـﺎي ﺧـﻮد‬ ‫را در ﺁن ذﺧﻴﺮﻩ آﺮدﻩ و در ﻣﻮﻗﻊ ﻟﺰوم ﺑﺮاي ﺧﻮاﻧﺪن ﺧﻂ ﺑﻪ ﺧﻂ دادﻩ هﺎي ذﺧﻴﺮﻩ ﺷﺪﻩ ﺑـﺎ اﺳـﺘﻔﺎدﻩ‬ ‫از ﺗﺎﺑﻊ )(‪ LineInput‬ﻳﺎ ﺑﺮاي ﺧﻮاﻧﺪن آﻞ ﻓﺎﻳﻞ از ﺗﺎﺑﻊ )(‪ FileGet‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫, )] ‪FilePut(file_number,value [,record_number‬‬ ‫)] ‪FileGet(file_number,value [,record_number‬‬ ‫اﻳﻦ دو ﺗﺎﺑﻊ ﺑﺮاي ﺧﻮاﻧﺪن ﻳﺎ ﻧﻮﺷﺘﻦ رآﻮردهﺎ ﺑﻪ ﻳﺎ از ﻓﺎﻳﻞ ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ FilePut‬ﺑﺮاي ﻧﻮﺷﺘﻦ رآﻮرد و ﺗﺎﺑﻊ )(‪ FileGet‬ﺑﺮاي ﺧﻮاﻧﺪن رآﻮرد اﺳﺘﻔﺎدﻩ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫ﺑﺮاي آﺎر ﺑﺎ اﻳﻦ ﺗﻮاﺑﻊ ﻧﻴﺎز ﺑﻪ داﻧﺴﺘﻦ ﺷﻤﺎرﻩ رآﻮردي دارﻳﺪ آـﻪ ﻣـﻲ ﺧﻮاهﻴـﺪ ﺁن را ﺑﺨﻮاﻧﻴـﺪ ﻳـﺎ در‬ ‫ﻓﺎﻳﻞ ﺑﻨﻮﻳﺴﻴﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،file_number‬ﺷﻤﺎرﻩ ﻓﺎﻳﻞ اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،record_number‬ﺷﻤﺎرﻩ رآﻮردي اﺳﺖ آﻪ ﺑﺎﻳﺪ ﺧﻮاﻧﺪﻩ ﻳﺎ ﻧﻮﺷﺘﻪ ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن ‪ record_number‬ﻳﻚ ﭘﺎراﻣﺘﺮ اﺧﺘﻴﺎري اﺳﺖ و ﭼﻨﺎﻧﭽﻪ از ذآﺮ ﺁن ﺧﻮدداري ﺷﻮد، رآـﻮرد‬ ‫در ﻣﻜﺎن ﻓﻌﻠﻲ اﺷﺎرﻩ ﮔﺮ ﻓﺎﻳﻞ ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮد. )در ﺗﺎﺑﻊ )(‪(FilePut‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،value‬ﻣﺘﻐﻴﺮ رآﻮردي اﺳﺖ آﻪ در ﻓﺎﻳﻞ ﻧﻮﺷﺘﻪ ﺷﺪﻩ اﺳﺖ ﻳﺎ ﻣﻲ ﺷﻮد.‬ ‫ﭘﺲ از اﻳﻨﻜﻪ ﻳﻚ رآﻮرد ﺑﻪ ﻓﺎﻳﻞ ﻧﻮﺷﺘﻪ ﻳﺎ از ﻓﺎﻳﻞ ﺧﻮاﻧـﺪﻩ ﺷـﺪ، رآـﻮرد ﺑﻌـﺪ از ﺁن ﺑـﻪ ﻋﻨـﻮان رآـﻮرد‬ ‫ﺟﺎري در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔﺮ ﺗﺎﺑﻊ )(‪ ١٠ ،FilePut‬ﺑﺎر ﭘـﺸﺖ ﺳـﺮ هـﻢ و ﺑـﺪون ﺗﻌﻴـﻴﻦ آـﺮدن ﺷـﻤﺎرﻩ رآـﻮرد‬ ‫ﻓﺮاﺧﻮاﻧﻲ ﺷﻮد، ٠١ رآﻮرد اول ﻓﺎﻳﻞ ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ، اﻳﺠﺎد ﻳﺎ ﺑﺎزﻧﻮﻳﺴﻲ ﻣﻲ ﺷﻮد.‬ ‫از ﺁﻧﺠﺎﻳﻲ آﻪ ﻓﺎﻳﻞ ﺑﺎ ﺳﺎﺧﺘﺎر دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ، اﻧﻌﻄﺎف ﭘﺬﻳﺮﺗﺮﻳﻦ ﺳﺎﺧﺘﺎر و ﺑﻴﺸﺘﺮﻳﻦ آﺎرﺑﺮد را‬ ‫دارد، ﺑﺎ ذآﺮ ﭼﻨﺪ ﻣﺜﺎل ﺑﺎ ﻧﺤﻮﻩ ﻋﻤﻠﻜﺮد اﻳﻦ ﺳﺎﺧﺘﺎر ﺑﻴﺸﺘﺮ ﺁﺷﻨﺎ ﻣﻲ ﺷﻮﻳﻢ:‬ ‫در اﻳﻨﺠﺎ ﻣﻦ ﻗﺼﺪ اﻳﺠﺎد ﻳﻚ ﻓﺎﻳﻞ ﻧﻮع دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ را ﺟﻬـﺖ ﻧﮕﻬـﺪاري ﻣﺸﺨـﺼﺎت ﻣﺤـﺼﻮل‬ ‫ﻳﻚ ﺷﺮآﺖ دارم. هﺮ ﻣﺸﺨﺼﻪ از اﻳﻦ ﻣﺤﺼﻮل در ﻳﻚ ﻣﺘﻐﻴﺰ ﺑﻪ ﻧﺎم ‪ ProductRecord‬ﻗﺮار ﺧﻮاهـﺪ‬ ‫ﮔﺮﻓﺖ. ﺳﺎﺧﺘﺎر ‪ ProductRecord‬را ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺗﻌﺮﻳﻒ ﻣﻲ آﻨﻢ:‬ ‫ﺗﻮﺟﻪ: در ‪ VB.NET‬از آﻠﻤﻪ آﻠﻴﺪي ‪ Structure‬ﺟﻬﺖ ﺗﻌﺮﻳـﻒ ﻳـﻚ ﺳـﺎﺧﺘﺎر ﺳﻔﺎرﺷـﻲ اﺳـﺘﻔﺎدﻩ‬ ‫ﻣﻲ آﻨﻴﻢ. اﻳﻦ آﻠﻤﻪ ﺟﺎﻳﮕﺰﻳﻦ آﻠﻤﻪ آﻠﻴﺪي ‪ Type‬در 0.6.‪ VB‬ﺷﺪﻩ اﺳﺖ.‬ ‫‪Structure ProductRecord‬‬ ‫‪ProductID As String‬‬ ‫‪Description As String‬‬ ‫‪Price As Decimal‬‬ ‫‪End Type‬‬ ‫اﻃﻼﻋﺎت آﺎﻻ ﻗﺒﻞ از ذﺧﻴﺮﻩ ﺷﺪن در ﻓﺎﻳﻞ، در هﺮ ﻳﻚ از اﻳﻦ ٣ ﻣﺘﻐﻴﺮ ﻗﺮار ﺧﻮاهﻨﺪ ﮔﺮﻓﺖ.‬ ‫ﺣــﺎﻻ ﺑــﺮاي دﺳﺘﺮﺳــﻲ ﺑــﻪ ﻓﻴﻠــﺪهﺎي اﻳــﻦ ﺳــﺎﺧﺘﺎر ﺑﺎﻳــﺪ ﻣﺘﻐﻴــﺮي از ﻧــﻮع اﻳــﻦ ﺳــﺎﺧﺘﺎر ﻳﻌﻨــﻲ‬ ‫‪ ProductRecord‬ﺗﻌﺮﻳﻒ آﻨﻴﻢ:‬ ‫‪Dim PRec As ProductRecord‬‬ ‫ﺣﺎل ﻣﻲ ﺗﻮاﻧﻴﻢ ﻣﻘﺎدﻳﺮ ﺧﻮد را ﺑﻪ ﻓﻴﻠﺪهﺎي ﻣﺘﻐﻴﺮ ‪ Prec‬ﻧﺴﺒﺖ دهﻴﻢ:‬ ‫” ‪PRec.ProductID = “TV00180-A‬‬ ‫” ‪PRec.Description = “SONY TV‬‬ ‫99.997 = ‪PRec.Price‬‬ ‫اآﻨﻮن هﻤﻪ ﭼﻴﺰ ﺑﺮاي ذﺧﻴﺮﻩ آﺮدن ﻣﻘﺎدﻳﺮ وارد ﺷﺪﻩ در ﻓﺎﻳﻞ ﻣﺎ ﺁﻣﺎدﻩ اﺳﺖ اﻣﺎ ﻗﺒﻞ از اﻧﺠـﺎم اﻳـﻦ‬ ‫آﺎر ﺑﺎﻳﺪ ﻓﺎﻳﻞ را اﻳﺠﺎد آﻨﻴﻢ:‬ ‫)(‪fNum =FreeFile‬‬ ‫)‪FileOpen(fNum, “C:products.dat ”,OpenMode.Random‬‬ ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ آﻪ ﻣﻦ در ﺗﺎﺑﻊ )(‪ FileOpen‬از ذآﺮ ﻣﺘﻐﻴﺮ ﺁﺧﺮ آﻪ ﻃـﻮل رآـﻮرد را ﺗﻌﻴـﻴﻦ ﻣـﻲ‬ ‫آﻨﺪ ﺧﻮدداري آﺮدم. از ﺁﻧﺠﺎﺋﻴﻜﻪ ﻓﻴﻠﺪهﺎي ﻣﺎ داراي ﻣﻘﺎدﻳﺮ رﺷﺘﻪ اي هﺴﺘﻨﺪ و ﻃـﻮل ﺁﻧﻬـﺎ از ﻗﺒـﻞ‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٩٤‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 50.
    ‫ﻣﺸﺨﺺ ﻧﻴﺴﺖ )ﻣﺘﻐﻴﺮاﺳﺖ(، اﺟﺎزﻩ ﻣﻲ دهﻴﻢ آﻪ ﺗﺎﺑﻊ ﺑﻪ ﻃﻮر ﺧﻮدآﺎر رآﻮردهـﺎ را ادارﻩ و ﻃـﻮل‬ ‫ﺁﻧﻬﺎ را ﻣﺪﻳﺮﻳﺖ آﻨﺪ. اﺻﻮل آﺎر ﺑﻪ اﻳﻦ ﺷﻜﻞ اﺳﺖ آﻪ هﻨﮕﺎم ذﺧﻴﺮﻩ ﻣﺘﻐﻴﺮ رﺷﺘﻪ اي، ﻃﻮل ﺁن ﻧﻴـﺰ‬ ‫هﻤﺮاﻩ ﺑﺎ ﻣﻘﺪار ﺁن در ﻓﺎﻳﻞ ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮد ﭘﺲ ﺷﻤﺎ ﻧﻴﺎزي ﺑﻪ داﻧﺴﺘﻦ ﻃﻮل هﺮ رآﻮرد ﻧﺪارﻳﺪ.‬ ‫و ﺣﺎﻻ ﻣﻘﺎدﻳﺮ ﻧﺴﺒﺖ دادﻩ ﺷﺪﻩ را ﺑﺎ دﺳﺘﻮر زﻳﺮ در ﻓﺎﻳﻞ ذﺧﻴﺮﻩ ﻣﻲ آﻨﻴﻢ:‬ ‫)‪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‬‬ ‫99.997 = ‪PRec.Price‬‬ ‫)(‪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‬‬ ‫99.996 = ‪PRec.Price‬‬ ‫)‪FilePut(fNum,PRec‬‬ ‫)(‪PRec =New ProductRecord‬‬ ‫”‪PRec.ProductID = “TV-FST‬‬ ‫” ‪PRec.Description = “And this is the real FST TV‬‬ ‫99.993 = ‪Prec.Price‬‬ ‫)‪FilePut(fNum,Prec‬‬ ‫)‪FileClose(fNum‬‬ ‫)(‪fNum = FreeFile‬‬ ‫)‪FileOpen(fNum, “C:products.dat ”, OpenMode.Random‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٠٥‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 51.
    ‫)(‪Prec =New ProductRecord‬‬ ‫)2,‪FileGet(fNum,Prec‬‬ ‫)‪FileClose(fNum‬‬ ‫)‪Console.WriteLine(Prec.ProductID‬‬ ‫)‪Console.WriteLine(Prec.Description‬‬ ‫)‪Console.WriteLine(Prec.Price‬‬ ‫هﻤﺎنﻃﻮر آﻪ ﻣﺸﺎهﺪﻩ ﻣﻲ آﻨﻴﺪ، ﻓﻴﻠـﺪهﺎي ‪ ProductID‬و ‪ Description‬ﻣﺤـﺼﻮﻻت ﻣﺨﺘﻠـﻒ،‬ ‫آﻪ از ﻧﻮع رﺷﺘﻪ اي هﺴﺘﻨﺪ داراي ﻃﻮل هﺎي ﻣﺨﺘﻠﻒ هﺴﺘﻨﺪ.‬ ‫ﺳﻪ ﻗﺴﻤﺖ اول آﺪ ﺑﺎﻻ، ٣ رآﻮرد ﻣﺨﺘﻠﻒ را در ﻓﺎﻳﻞ ﺗﺼﺎدﻓﻲ ذﺧﻴﺮﻩ آﺮدﻩ و ﺳـﭙﺲ ﻓﺎﻳـﻞ را ﻣـﻲ‬ ‫ﺑﻨﺪد.‬ ‫ﻗﺴﻤﺖ ﺁﺧﺮ آﺪ ﻧﻴﺰ، دوﻣﻴﻦ رآﻮرد ﻓﺎﻳﻞ را ﺧﻮاﻧﺪﻩ و ﻣﻘﺎدﻳﺮ ﺁن را در ﺧﺮوﺟﻲ ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ.‬ ‫ﻧﻜﺘﻪ: در 0.6.‪ ،VB‬هﺮ رآﻮرد در ﻓﺎﻳﻞ ﺗﺼﺎدﻓﻲ ﺑﺎﻳﺪ داراي ﻃـﻮل ﺛﺎﺑـﺖ ﻣـﻲ ﺑـﻮد اﻣـﺎ در ‪،VB.NET‬‬ ‫ﻣﻲ ﺗﻮاﻧﻴﺪ رآﻮردهﺎﻳﻲ اﻳﺠﺎد و در ﻓﺎﻳﻞ ﺗﺼﺎدﻓﻲ ﻗﺮار دهﻴﺪ آﻪ داراي ﻃﻮل ﻣﺘﻐﻴﺮ ﺑﺎﺷﻨﺪ.‬ ‫)‪Write(file_number,output_list) , WriteLine(file_number,output_list‬‬ ‫ﺗﺎﺑﻊ )(‪ Write‬ﺟﻬﺖ ذﺧﻴﺮﻩ دادﻩ هﺎ در ﻳﻚ ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ ﺑﻪ آﺎر ﻣﻲ رود.‬ ‫ﺁرﮔﻮﻣﺎن ‪ file_number‬ﺷﻤﺎرﻩ ﻓﺎﻳﻠﻲ اﺳﺖ آﻪ دادﻩ هﺎ در ﺁن ذﺧﻴﺮﻩ ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ output_list‬ﻧﻴﺰ آﻪ ﻳﻚ ﺁراﻳﻪ ي ﭘﺎراﻣﺘﺮي اﺳﺖ، ﻟﻴﺴﺘﻲ از دادﻩ هﺎﻳﻲ اﺳـﺖ آـﻪ ﻣـﻲ‬ ‫ﺧﻮاهﻴﻢ در ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ ﻧﻮﺷﺘﻪ ﺷﻮﻧﺪ و ﻣﻲ ﺗﻮاﻧﻨﺪ ﻣﺘﻐﻴﺮهـﺎي ﻣﻘـﺪاردهﻲ ﺷـﺪﻩ ﻳـﺎ ﺧـﻮد ﻣﻘـﺪار‬ ‫ﻣﻮرد ﻧﻈﺮ ﺑﺎﺷﻨﺪ. دادﻩ هﺎ در ﺁرﮔﻮﻣﺎن ‪ ،output_list‬ﺑﺎ آﺎراآﺘﺮ ),( از ﻳﻜﺪﻳﮕﺮ ﺟﺪا ﻣﻲ ﺷﻮﻧﺪ.‬ ‫دادﻩ هﺎﻳﻲ آﻪ ﺑﺎ ﺗﺎﺑﻊ )(‪ Write‬در ﻓﺎﻳﻞ ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮﻧﺪ ﻣﻌﻤﻮﻻ ﺑﺎ ﺗـﺎﺑﻊ )(‪ Input‬ﺧﻮاﻧـﺪﻩ ﻣـﻲ‬ ‫ﺷﻮﻧﺪ.‬ ‫دﺳﺘﻮرات زﻳﺮ، ﻳﻚ ﻣﻘﺪار ﻋﺪدي و ﻳﻚ ﻣﻘﺪار از ﻧﻮع ﺗﺎرﻳﺦ را در ﻳﻚ ﻓﺎﻳﻞ ﺗﺮﺗﻴﺒﻲ ﻣﻲ ﻧﻮﻳﺴﻨﺪ:‬ ‫400.0033 = ‪NumVal‬‬ ‫#9991/90/40# = ‪DateVal‬‬ ‫)‪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‬‬ ‫ﺧﺮوﺟﻲ دﺳﺘﻮرات ﻓﻮق ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺧﻮاهﺪ ﺷﺪ:‬ ‫”‪“Behrouz Rad”, 33, ”Manager‬‬ ‫”‪“Sina Ahmadi”, 24, ”Programmer‬‬ ‫”‪“Arvin Sanaei”, 37, ”Engineer‬‬ ‫”‪“Pedram Amiri”, 28, ”Administrator‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫١٥‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 52.
    ‫)‪Seek(file_number [,position ]), Loc(file_number‬‬ ‫ﺗﺎﺑﻊ )(‪ ،Loc‬ﻣﻜﺎن ﺟﺎري اﺷﺎرﻩ ﮔﺮ ﻓﺎﻳﻞ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺗﺎﺑﻊ )(‪ Seek‬ﻧﻴﺰ در ﺻﻮرﺗﻲ آﻪ ﺑﺪون ذآﺮ ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ position‬ﺑﻪ آﺎر رود، ﻋﻤﻠﻲ ﻣـﺸﺎﺑﻪ‬ ‫ﺗﺎﺑﻊ )(‪ Loc‬را اﻧﺠﺎم ﻣﻲ دهﺪ.‬ ‫در ﻓﺎﻳﻞ هﺎي ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ، ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ دو ﺗﺎﺑﻊ، ﺷﻤﺎرﻩ ﺁﺧـﺮﻳﻦ رآـﻮردي اﺳـﺖ‬ ‫آﻪ از ﻓﺎﻳﻞ ﺧﻮاﻧﺪﻩ ﺷﺪﻩ ﻳﺎ در ﻓﺎﻳﻞ ﻧﻮﺷﺘﻪ ﺷﺪﻩ.‬ ‫در ﻓﺎﻳﻞ هﺎي ﺗﺮﺗﻴﺒﻲ، اﻳﻦ ﻣﻘﺪار، ﺑﺎ ﺗﻘﺴﻴﻢ ﺑﺎﻳﺖ ﺧﻮاﻧﺪﻩ ﺷﺪﻩ ﺟﺎري ﺑﺮ ﻋﺪد ٨٢١ ﺑﻪ دﺳـﺖ ﻣـﻲ‬ ‫ﺁﻳﺪ.‬ ‫در ﻓﺎﻳﻞ هﺎي ﺑﺎﻳﻨﺮي ﻧﻴﺰ، ﺷﻤﺎرﻩ ﺁﺧﺮﻳﻦ ﺑﺎﻳﺖ ﺧﻮاﻧﺪﻩ ﺷﺪﻩ از ﻳﺎ ﻧﻮﺷﺘﻪ ﺷـﺪﻩ ﺑـﻪ ﻓﺎﻳـﻞ ﺑـﻪ ﻋﻨـﻮان‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ ﺧﻮاهﺪ ﺑﻮد.‬ ‫ﺷﻤﺎ ﻗﺎدر ﺑﻪ ﺗﻌﻴﻴﻦ ﻣﻜﺎن ﺷﺮوع ﺧﻮاﻧﺪن ﻳﺎ ﻣﻜﺎن ﻧﻮﺷﺘﻪ ﺷﺪن رآـﻮرد در ﻓﺎﻳـﻞ ﺑـﺎ ﻣﻘـﺪاردهﻲ ﺑـﻪ‬ ‫ﺁرﮔﻮﻣﺎن ‪ position‬از ﺗﺎﺑﻊ )(‪ Seek‬هﺴﺘﻴﺪ.‬ ‫ﻣﺜﻼ ﺑﺮاي ﺁﻧﻜﻪ اﺷﺎرﻩ ﮔﺮ رآﻮرد را در ﻳﻚ ﻓﺎﻳﻞ ﺑﺎ دﺳﺘﺮﺳﻲ ﺗﺼﺎدﻓﻲ ﺑﻪ ﺳﻮﻣﻴﻦ رآﻮرد ﺑﺒﺮﻳﺪ ﻳﺎ ﺑـﻪ‬ ‫ﻋﺒﺎرت دﻳﮕﺮ ﺁن را ﺑﻪ ﻋﻨﻮان رآﻮرد ﻓﻌﺎل ﻣﻨﻈﻮر آﻨﻴﺪ، ﻣﻲ ﺗﻮاﻧﻴﺪ از دﺳﺘﻮر زﻳﺮ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ:‬ ‫)3,‪Seek(fNum‬‬ ‫, )] ‪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‬‬
  • 53.
    ‫)‪Width(fNum,length‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﻧﻴﺰﻳﻚ ﺑﺴﻴﺎر ﺑـﺴﻴﺎر آﺎرﺁﻣـﺪ اﺳـﺖ آـﻪ ﺟﻬـﺖ ﺗﻌﻴـﻴﻦ ﺑﻴـﺸﺘﺮﻳﻦ ﻃـﻮل ﺧـﻂ ﻳﻌﻨـﻲ ﺗﻌـﺪاد‬ ‫آﺎراآﺘﺮهﺎي ﻗﺎﺑﻞ ذﺧﻴﺮﻩ ﺳﺎزي در هﺮ ﺧﻂ آﻪ ﻣﻲ ﺗﻮاﻧﺪ در ﻳﻚ ﻓﺎﻳـﻞ ﺗﺮﺗﻴﺒـﻲ ﻧﻮﺷـﺘﻪ ﺷـﻮد، ﺑـﻪ‬ ‫آﺎر ﻣﻲ رود.‬ ‫ﺑﻴﺸﺘﺮﻳﻦ ﻃﻮل ﺧﻂ ﺑﻪ وﺳﻴﻠﻪ ي ﺁرﮔﻮﻣﺎن ‪ length‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد.‬ ‫در ﺻــﻮرﺗﻲ آــﻪ آﺎراآﺘﺮهــﺎي ﺷــﻤﺎ از ﺗﻌــﺪاد ﺗﻌﻴــﻴﻦ ﺷــﺪﻩ در ﺁرﮔﻮﻣــﺎن ‪ length‬ﺑﻴــﺸﺘﺮ ﺑﺎﺷــﺪ،‬ ‫آﺎراآﺘﺮهﺎي اﺿﺎﻓﻲ ﺑﻪ ﻃﻮر اﺗﻮﻣﺎﺗﻴﻚ ﺑﻪ ﺧﻂ ﺑﻌﺪ ﻣﻨﺘﻘﻞ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫اﺑﻦ ﺗﺎﺑﻊ را ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺎ ﺗﻮاﺑﻊ )(‪ Print‬و )(‪) Write‬آﻪ دادﻩ هـﺎ را در ﻳـﻚ ﺧـﻂ و ﭘـﺸﺖ ﺳـﺮ هـﻢ‬ ‫ذﺧﻴﺮﻩ ﻣﻲ آﻨﻨﺪ( ﺟﻬﺖ ﺗﻌﻴﻴﻦ ﺗﻌﺪاد آﺎراآﺘﺮهﺎي ذﺧﻴﺮﻩ ﺷﻮﻧﺪﻩ در هﺮ ﺧﻂ، ﺑﻪ آﺎر ﺑﺮﻳﺪ.‬ ‫هﻤﭽﻨﻴﻦ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺗﺎﺑﻊ )(‪ Width‬را ﺑﺎ ﺗﻮاﺑﻊ )(‪ PrintLine‬و )(‪ WriteLine‬ﻧﻴـﺰ )آـﻪ دادﻩ هـﺎ را‬ ‫در ﺧﻄﻮط ﺟﺪا ذﺧﻴﺮﻩ ﻣﻲ آﻨﻨﺪ( ﺑﻪ آﺎر ﺑﺒﺮﻳﺪ.‬ ‫)‪FileAttr(file_number‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻳﻚ ﻋﺪد از ﻧﻮع ‪ Integer‬را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ آﻪ ﻣـﺸﺨﺺ آﻨﻨـﺪﻩ ي ﺣﺎﻟـﺖ ﺑـﺎز ﺷـﺪن‬ ‫ﻳﻚ ﻓﺎﻳﻞ ﺑﺎز اﺳﺖ.‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ، در ﺟﺪول زﻳﺮ ﻣﺸﺎهﺪﻩ ﻣﻲ آﻨﻴﺪ:‬ ‫ﻣﻘﺎدﻳﺮي آﻪ ﺗﺎﺑﻊ )(‪ FileAttr‬ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ‬ ‫ﻣﺪ ﺑﺎز ﺷﺪن‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ‬ ‫‪Input‬‬ ‫1‬ ‫‪Output‬‬ ‫2‬ ‫‪Random‬‬ ‫4‬ ‫‪Append‬‬ ‫8‬ ‫‪Binary‬‬ ‫23‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٣٥‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 54.
    ‫)‪:(Random Numbers‬‬ ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺮاي اﻳﺠﺎد اﻋﺪاد ﺗﺼﺎدﻓﻲ ﺑﻪ آﺎر ﻣﻲ روﻧﺪ‬ ‫‪ VB.NET‬دو ﺗﺎﺑﻌﻲ آﻪ در 0.6.‪ VB‬ﺑﺮاي درﺳﺖ آﺮدن اﻋﺪاد ﺗﺼﺎدﻓﻲ ﺑﻪ آـﺎر ﻣـﻲ روﻧـﺪ )‪ Rnd‬و‬ ‫‪ (Randomize‬را ﭘﺸﺘﻴﺒﺎﻧﻲ ﻣﻲ آﻨﺪ اﻣﺎ از ﺁﻧﺠﺎ آﻪ در ‪ ،VB.NET‬اآﺜـﺮ ﺗﻮاﺑـﻊ، دﺳـﺘﻪ ﺑﻨـﺪي و در‬ ‫آﻼس ﺧﺎص ﺧﻮدﺷﺎن ﻗﺮار دادﻩ ﺷﺪﻩ اﻧﺪ، اﻳـﻦ دو ﺗـﺎﺑﻊ ﻧﻴـﺰ در آـﻼس ‪ System.Random‬ﻗـﺮار‬ ‫دادﻩ ﺷﺪﻩ اﻧﺪ.‬ ‫)] ‪Rnd([seed‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، در ﺻﻮرﺗﻲ آﻪ ﺑﺪون ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ﺧﻮد ﺑﻪ آﺎر رود، ﻳﻚ ﻋﺪد ﺗﺼﺎدﻓﻲ ﺑـﻴﻦ ﺻـﻔﺮ و ﻳـﻚ‬ ‫را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،seed‬ﻳﻚ ﻋﺒﺎرت ﻋﺪدي اﺳﺖ آﻪ ﻋﺪد ﺗﺼﺎدﻓﻲ ﺑﺎﻳﺪ ﺑﺮ ﺣﺴﺐ ﺁن ﺗﻮﻟﻴﺪ ﺷﻮد.‬ ‫ﻣﺜﻼ دﺳﺘﻮر 01*)(‪ ،Rnd‬ﻳﻚ ﻋﺪد ﺗﺼﺎدﻓﻲ ﺑﻴﻦ ﺻﻔﺮ و دﻩ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﻧﻜﺘﻪ: هﻤﻴﺸﻪ ﺑﻴﻦ ﺗﺎﺑﻊ )(‪ Rnd‬و ﻋﺪدي آﻪ ﻣﻲ ﺧﻮاهﻴﺪ ﻋﺪد ﺗﺼﺎدﻓﻲ ﺑﺮ ﻣﺒﻨﺎي ﺁن ﺗﻮﻟﻴﺪ ﺷـﻮد،‬ ‫از آﺎراآﺘﺮ )*( اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﺗﻮﺟﻪ: ﺗﺮﺗﻴﺐ ﺗﻮﻟﻴﺪ اﻋﺪاد ﺗﺼﺎدﻓﻲ در اﻳـﻦ ﺗـﺎﺑﻊ هﻤﻴـﺸﻪ ﺑـﻪ ﻳـﻚ ﻣﻨـﻮال اﺳـﺖ. ﻣـﺜﻼ اﮔـﺮ دﺳـﺘﻮر‬ ‫01*)(‪ Rnd‬را ٣ ﺑﺎر ﭘﺸﺖ ﺳﺮ هﻢ اﺟـﺮا آﻨـﻴﻢ، هﻤﻴـﺸﻪ ﺳـﻪ ﻋـﺪد )574550.7، 42433.5،‬ ‫681597.5( ﺑﺮﮔﺸﺖ دادﻩ ﺧﻮاهﺪ ﺷﺪ.‬ ‫ﺑﺮاي ﺟﻠﻮﮔﻴﺮي از اﻳﻦ آـﺎر و ﺗﻐﻴﻴـﺮ ﺗﺮﺗﻴـﺐ ﺗﻮﻟﻴـﺪ اﻋـﺪاد ﺗـﺼﺎدﻓﻲ، از ﺗـﺎﺑﻊ )(‪ Randomize‬آـﻪ در‬ ‫ﻗﺴﻤﺖ ﺑﻌﺪي ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻩ اﺳﺖ، اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﻣﺜﻼ:‬ ‫‪Dim I as Integer‬‬ ‫)(‪Randomize‬‬ ‫01 * )(‪I = Rnd‬‬ ‫اﮔﺮ ﻣﻘﺪاري در ﺁرﮔﻮﻣﺎن ‪ seed‬ذآﺮ ﺷﻮد، ﻋﺪد ﺗـﺼﺎدﻓﻲ آـﻪ اﻳﺠـﺎد ﺧﻮاهـﺪ ﺷـﺪ، ﺑـﻴﻦ ﺻـﻔﺮ ﺗـﺎ ﺁن‬ ‫ﻋﺪدي اﺳﺖ آﻪ در ﺁرﮔﻮﻣﺎن ‪ seed‬ذآﺮ ﺷﺪﻩ. ﮔﺎهﻲ اوﻗﺎت ﻧﻴﺎز دارﻳﺪ ﺗﺎ ﺑـﻴﻦ ﻣﺤـﺪودﻩ اي دﻟﺨـﻮاﻩ‬ ‫ﻣﺜﻼ: 5 ﺗﺎ 01، ﻋﺪدي ﺗﺼﺎدﻓﻲ اﻳﺠﺎد آﻨﻴﺪ. ﺑﺪﻳﻦ ﻣﻨﻈﻮر ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ آﻨﻴﺪ:‬ ‫)‪randomNumber =Int((upper – lower + 1) * Rnd() + lower‬‬ ‫در اﻳﻦ دﺳﺘﻮر، ﻣﺘﻐﻴﺮ ‪ ،upper‬ﺣﺪ ﺑـﺎﻻي ﻣﺤـﺪودﻩ ي ﻣـﺎ )ﻣـﺜﻼ 01( و ﻣﺘﻐﻴـﺮ ‪ ،lower‬ﺣـﺪ ﭘـﺎﻳﻴﻦ‬ ‫ﻣﺤﺪودﻩ )ﻣﺜﻼ 5( اﺳﺖ.‬ ‫ﻧﻜﺘﻪ: در آﺪ ﺑﺎﻻ، ﺟﻤﻊ آﺮدن ﻧﺘﻴﺠﻪ ﻗﺴﻤﺖ اول ﺑﺎ ﻋﺪد 1، از ﺗﻮﻟﻴﺪ ﻋﺪد ﺗﺼﺎدﻓﻲ ﺑﻴﻦ ﺻﻔﺮ و ﻳـﻚ‬ ‫ﺟﻠﻮﮔﻴﺮي ﻣﻲ آﻨﺪ. ﭘﻴﺸﻨﻬﺎد ﻣﻲ آﻨﻢ هﻤﻴﺸﻪ در ﺗﻮﻟﻴﺪ اﻋﺪاد ﺗـﺼﺎدﻓﻲ، ﻣﻘـﺪار ‪ seed‬را ﺑـﺎ ﻋـﺪد‬ ‫ﻳﻚ ﺟﻤﻊ آﻨﻴﺪ.‬ ‫ﺗﻮﺟﻪ: ﺗﺎﺑﻊ ‪ Next‬ﻧﻴﺰ آﻪ در آﻼس ‪ System.Random‬ﻗﺮار دارد ﻗﺎدر ﺑﻪ اﻳﺠﺎد ﻳﻚ ﻋﺪد ﺗـﺼﺎدﻓﻲ‬ ‫در ﻣﺤﺪودﻩ اي ﺧﺎص اﺳﺖ.‬ ‫] ‪Randomize [seed‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، هﺴﺘﻪ ي ﺗﻮﻟﻴﺪ اﻋﺪاد ﺗﺼﺎدﻓﻲ را ﺗﻐﻴﻴﺮ ﻣﻲ دهﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ هﻤﻴﺸﻪ ﺑﺎ ﺗﺎﺑﻊ )(‪ Rnd‬ﺑﻪ آﺎر ﻣﻲ رود و ﻣﻌﻤﻮﻻ ﻗﺒﻞ از ﺁن ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،seed‬ﻳﻚ ﻣﻘﺪار ﻋﺪدي اﺳﺖ آﻪ ﺑﺮاي ﺗﻮﻟﻴﺪ هﺴﺘﻪ ي اﻋﺪاد ﺗـﺼﺎدﻓﻲ ﺑـﻪ آـﺎر‬ ‫ﻣﻲ رود. ﺑﻬﺘﺮ اﺳﺖ از ذآﺮ اﻳﻦ ﻣﻘﺪار ﺧﻮدداري آﻨﻴﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٤٥‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 55.
    ‫)‪:(Graphics‬‬ ‫ﺗﻮاﺑﻊ ﮔﺮاﻓﻴﻜﻲ‬ ‫در اﻳﻦ ﻗﺴﻤﺖ، دو ﺗﺎﺑﻊ در ‪ VB.NET‬آﻪ ﺑﺮاي ﺗﻌﺮﻳﻒ رﻧـﮓ ار ﺁﻧﻬـﺎ اﺳـﺘﻔﺎدﻩ ﻣـﻲ ﺷـﻮد را ﺗﻮﺿـﻴﺢ‬ ‫ﻣﻲ دهﻢ.‬ ‫ﺗﻮﺟﻪ: ﺗﻮاﺑـﻊ )(‪ LoadPicture‬و )(‪ SavePicture‬آـﻪ در 0.6.‪ VB‬وﺟـﻮد داﺷـﺘﻨﺪ، در ‪VB.NET‬‬ ‫وﺟﻮد ﻧﺪارﻧﺪ.‬ ‫)‪QBColor(color‬‬ ‫اﻳـﻦ ﺗـﺎﺑﻊ، ﺑـﺮاي ﺗﻮﻟﻴـﺪ ﺗﻌـﺪادي رﻧـﮓ از ﭘـﻴﺶ ﺗﻌﺮﻳـﻒ ﺷـﺪﻩ ﺑـﻪ آـﺎر ﻣـﻲ رود و ﻣﻘـﺪاري از ﻧـﻮع‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ ـ‬ ‫‪ Integer‬آﻪ ﻣﻌﺮف آﺪ رﻧﮓ اﻳﺠﺎد ﺷﺪﻩ اﺳﺖ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،Color‬آﺪ رﻧﮕﻲ اﺳﺖ آﻪ ﺑﺎﻳﺪ ﺗﻮﻟﻴﺪ ﺷﻮد و ﻋﺪدي ﺑﻴﻦ 0 ﺗﺎ 51 اﺳﺖ.‬ ‫ﻣﻘﺎدﻳﺮي را آﻪ اﻳﻦ ﺁرﮔﻮﻣﺎن ﻣﻲ ﺗﻮاﻧﺪ ﺑﭙﺬﻳﺮد، در ﺟﺪول زﻳﺮ ﺁﻣﺪﻩ اﺳﺖ:‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ color‬در ﺗﺎﺑﻊ )(‪QBColor‬‬ ‫رﻧﮓ‬ ‫ﻣﻘﺪار‬ ‫ﺳﻴﺎﻩ‬ ‫0‬ ‫ﺁﺑﻲ‬ ‫1‬ ‫ﺳﺒﺰ‬ ‫2‬ ‫ﻻﺟﻮردي‬ ‫3‬ ‫ﻗﺮﻣﺰ‬ ‫4‬ ‫ارﻏﻮاﻧﻲ‬ ‫5‬ ‫زرد‬ ‫6‬ ‫ﺳﻔﻴﺪ‬ ‫7‬ ‫ﺧﺎآﺴﺘﺮي‬ ‫8‬ ‫ﺁﺑﻲ روﺷﻦ‬ ‫9‬ ‫ﺳﺒﺰ روﺷﻦ‬ ‫01‬ ‫ﻻﺟﻮردي روﺷﻦ‬ ‫11‬ ‫ﻗﺮﻣﺰ روﺷﻦ‬ ‫21‬ ‫ارﻏﻮاﻧﻲ روﺷﻦ‬ ‫31‬ ‫زرد روﺷﻦ‬ ‫41‬ ‫ﺳﻔﻴﺪ روﺷﻦ )ﺑﺎ ﺷﺪت ﺑﺎﻻ(‬ ‫51‬ ‫آﺎرﺑﺮد اﻳﻦ ﺗﺎﺑﻊ ﺑﻴﺸﺘﺮ در ﺳﻴﺴﺘﻢ هﺎﻳﻲ اﺳﺖ آﻪ آﺎرت ﮔﺮاﻓﻴﻚ ﺁﻧﻬﺎ ﻧﺼﺐ ﻧﺸﺪﻩ ﻳﺎ ﺗﻨﻬﺎ ﻗـﺎدر ﺑـﻪ‬ ‫ﭘﺸﺘﻴﺒﺎﻧﻲ از ٦١ رﻧﮓ ﻣﻲ ﺑﺎﺷﻨﺪ آﻪ در ﺳﻴﺴﺘﻢ هﺎي ﻗﺪﻳﻤﻲ آﺎرﺑﺮد ﺑﻴﺸﺘﺮي دارد.‬ ‫)‪RGB(red,green,blue‬‬ ‫رﻧﮓ هﺎ داراي ٤ ﻣﺪل اﺻﻠﻲ هﺴﺘﻨﺪ.‬ ‫ﻣﺪل، روش ﺗﻌﺮﻳﻒ ﻳﻚ رﻧﮓ را ﻣﺸﺨﺺ ﻣﻲ آﻨﺪ.‬ ‫ﻣﺪﻟﻲ آﻪ ﻣﺎﻧﻴﺘﻮر و ﺗﻠﻮﻳﺰﻳﻮن ﺧﺎﻧﻪ ي ﻣﺎ ﺟﻬﺖ ﻧﻤﺎﻳﺶ رﻧﮓ هﺎ از ﺁن اﺳﺘﻔﺎدﻩ ﻣﻲ آﻨﺪ ﻣﺪل ‪RGB‬‬ ‫ﻧﺎم دارد. در اﻳﻦ ﻣﺪل، ٣ رﻧﮓ اﺻﻠﻲ وﺟﻮد دارد آﻪ ﺑﻘﻴﻪ رﻧﮓ هﺎ از اﻳﻦ ٣ رﻧﮓ ﻣﺸﺘﻖ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫رﻧﮓ هﺎي اﻳﻦ ﻣﺪل ﻋﺒﺎرﺗﻨﺪ از: ﻗﺮﻣﺰ )‪ ،(Red‬ﺳﺒﺰ )‪ ،(Green‬ﺁﺑﻲ )‪(Blue‬‬ ‫ﻧﺎم اﻳﻦ ﻣﺪل از ﺣﺮوف اول اﻳﻦ ٣ رﻧﮓ ﮔﺮﻓﺘﻪ ﺷﺪﻩ اﺳﺖ.‬ ‫داﻣﻨﻪ ي هﺮ آﺪام از اﻳﻦ ٣ رﻧﮓ، ﻋﺪدي ﺑﻴﻦ 0 ﺗﺎ 552 اﺳﺖ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ اﻳﻦ ﺗﺎﺑﻊ، ﻗﺎدر ﺑﻪ ﺗﻮﻟﻴﺪ هﺮ ﻳﻚ از رﻧﮓ هﺎي ﻣﺪل ‪ RGB‬هﺴﺘﻴﻢ.‬ ‫ﺗﻌـــﺪاد رﻧـــﮓ هـــﺎي ﻣﻮﺟـــﻮد در ﻣـــﺪل ‪ ١٦٧٧٧٢١٦ ،RGB‬رﻧـــﮓ اﺳـــﺖ آـــﻪ از ﺿـــﺮب ٣ ﻋـــﺪد‬ ‫)652*652*652( ﺑﻪ دﺳﺖ ﻣﻲ ﺁﻳﺪ.‬ ‫ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ ﺗﺎﺑﻊ، ﻋﺪدي از ﻧﻮع ‪ Long‬اﺳﺖ آﻪ آﺪ رﻧﮓ ﺗﻮﻟﻴﺪ ﺷﺪﻩ را ﻧﺸﺎن ﻣﻲ دهﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٥٥‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 56.
    ‫در ﺟﺪول زﻳﺮ،آﺪ ﺗﻌﺪادي از رﻧﮓ هﺎي ﻣﺘﺪاول را در ﻣﺪل ‪ ،RGB‬ﻣﻼﺣﻈﻪ ﻣﻲ آﻨﻴﺪ:‬ ‫آﺪ ﻣﻌﺎدل ﺗﻌﺪادي از رﻧﮓ هﺎي ﭘﺮآﺎرﺑﺮد در ﻣﺪل ‪RGB‬‬ ‫آﺪ ﭘﺎراﻣﺘﺮ ‪blue‬‬ ‫آﺪ ﭘﺎراﻣﺘﺮ ‪green‬‬ ‫آﺪ ﭘﺎراﻣﺘﺮ ‪red‬‬ ‫رﻧﮓ‬ ‫0‬ ‫0‬ ‫0‬ ‫ﺳﻴﺎﻩ‬ ‫552‬ ‫0‬ ‫0‬ ‫ﺁﺑﻲ‬ ‫0‬ ‫552‬ ‫0‬ ‫ﺳﺒﺰ‬ ‫552‬ ‫552‬ ‫0‬ ‫ﻻﺟﻮردي‬ ‫0‬ ‫0‬ ‫552‬ ‫ﻗﺮﻣﺰ‬ ‫552‬ ‫0‬ ‫552‬ ‫ارﻏﻮاﻧﻲ‬ ‫0‬ ‫552‬ ‫552‬ ‫زرد‬ ‫552‬ ‫552‬ ‫552‬ ‫ﺳﻔﻴﺪ‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل، دﺳﺘﻮر زﻳﺮ، ﻳﻚ رﻧﮓ ﻗﺮﻣﺰ ﺧﺎﻟﺺ را اﻳﺠـﺎد و ﺑـﻪ ﭘـﺲ زﻣﻴﻨـﻪ ي ﻋﻨـﺼﺮ ‪،TextBox‬‬ ‫ﻧﺴﺒﺖ ﻣﻲ دهﺪ:‬ ‫)0 ,0 ,552(‪Text1.BackColor = RGB‬‬ ‫ﻓﺮﻣﻮل ﺗﺒﺪﻳﻞ ﻣﻘﺪار ‪ RGB‬ﺑﻪ ﻣﻌﺎدل ‪:Long‬‬ ‫2 ^ 652 * ‪r + g * 256 + b‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٦٥‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 57.
    ‫)‪:(Registry‬‬ ‫ﺗﻮاﺑﻌﻲ آﻪ ﺑﺎ رﺟﻴﺴﺘﺮي ﺳﺮ و آﺎر دارﻧﺪ‬ ‫در ‪ ،VB‬ﺗﻌﺪادي ﺗﺎﺑﻊ ﺑﺮاي ﺧﻮاﻧﺪن و ﻧﻮﺷﺘﻦ ﻣﻘﺎدﻳﺮ ﻣﺨﺘﻠﻒ در رﺟﻴﺴﺘﺮي وﻳﻨﺪوز وﺟﻮد دارد.‬ ‫)‪SaveSetting(appname, section, key, setting‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺟﻬﺖ ذﺧﻴﺮﻩ ﺳﺎزي ﻳـﻚ ﻣﻘـﺪار دﻟﺨـﻮاﻩ در رﺟﻴـﺴﺘﺮي ﻳـﺎ ﺑـﻪ هﻨﮕـﺎم آـﺮدن ﺁن ﻣﻘـﺪار از‬ ‫ﻃﺮﻳﻖ ﻧﻮﺷﺘﻦ ﺁن ﺑﺮ روي ﻣﻘﺪار ﻗﺒﻠﻲ، ﺑﻪ آﺎر ﻣﻲ رود.‬ ‫از اﻳﻦ ﺗﺎﺑﻊ ﻣﻌﻤﻮﻻ ﺑﺮاي ذﺧﻴﺮﻩ ﺗﻨﻈﻴﻤﺎت ﺑﺮﻧﺎﻣﻪ، اﺳﺘﻔﺎدﻩ ﻣﻲ ﺷﻮد.‬ ‫ﻣﻘﺎدﻳﺮ در ﻳﻚ ﻣﺴﻴﺮ اﺻﻠﻲ، ﻳﻚ ﺷﺎﺧﻪ، ﻳﻚ زﻳﺮﺷﺎﺧﻪ و در ﻧﻬﺎﻳﺖ ﺑﻪ ﺻﻮرت ﻳﻚ ﻣﻘـﺪار رﺷـﺘﻪ اي،‬ ‫در زﻳﺮﺷﺎﺧﻪ ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ.‬ ‫ﻧﻜﺘﻪ: ﻣﺴﻴﺮ اﺻﻠﻲ ﺗﻮﺳﻂ ‪ VB‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد و ﻧﻴﺎزي ﺑﻪ وارد آﺮدن ﺁن ﻧﻴﺴﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،appname‬ﻧﺎم ﺷﺎﺧﻪ ﻳﺎ ﭘﻮﺷﻪ ي اﺻﻠﻲ اﺳﺖ آﻪ ﺗﻤﺎم زﻳﺮﭘﻮﺷﻪ هﺎ و ﻣﻘـﺎدﻳﺮ ﺁﻧﻬـﺎ در‬ ‫اﻳﻦ ﺷﺎﺧﻪ ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ. ﻣﻲ ﺗﻮاﻧﻴﺪ هﺮ ﻧﺎم دﻟﺨﻮاهﻲ ﺑﻪ اﻳﻦ ﻧﺎم ﺑﺪهﻴﺪ اﻣﺎ ﺑﺮاي راﺣﺘﻲ آـﺎر‬ ‫ﺑﻬﺘﺮ اﺳﺖ ﻧﺎم ﺑﺮﻧﺎﻣﻪ ي ﺧﻮد را در اﻳﻦ ﺁرﮔﻮﻣﺎن ذآﺮ آﻨﻴﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ section‬ﻧﻴﺰ ﻧﺎم زﻳﺮ ﺷﺎﺧﻪ اي در ﺷﺎﺧﻪ ‪ appname‬اﺳﺖ آﻪ ﻣﻘﺎدﻳﺮ ﻣﺮﺑﻮط ﺑﻪ هـﻢ در‬ ‫اﻳﻦ زﻳﺮﺷﺎﺧﻪ ذﺧﻴﺮﻩ ﻣﻲ ﺷﻮﻧﺪ. ﻧﺎم اﻳﻦ ﺁرﮔﻮﻣﺎن ﻧﻴﺰ دﻟﺨﻮاﻩ اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،key‬ﻧﺎم ﻣﻘﺪار و ﺁرﮔﻮﻣﺎن ‪ setting‬ﻧﻴﺰ ﺧﻮد ﻣﻘﺪاري اﺳﺖ آﻪ ﺑﺎﻳﺪ ذﺧﻴﺮﻩ ﺷﻮد.‬ ‫اﮔﺮ ﻣﻘﺪار ‪ setting‬ﺑﻪ هﺮ دﻟﻴﻠﻲ ذﺧﻴﺮﻩ ﻧﺸﻮد، ﻳﻚ ﺧﻄﺎي زﻣﺎن اﺟﺮا در ﺑﺮﻧﺎﻣﻪ اﺗﻔﺎق ﻣﻲ اﻓﺘﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻓﺮض آﻨﻴﺪ آﻪ ﻣﻘﺪار ﻃﻮل و ﻋﺮض ﻓﺮم ﺑﺮﻧﺎﻣﻪ ي ﻣﺎ، ﺗﻮﺳﻂ آـﺎرﺑﺮ در زﻣـﺎن اﺟـﺮاي‬ ‫ﺑﺮﻧﺎﻣﻪ ﺗﻐﻴﻴﺮ ﭘﻴﺪا آﻨﺪ و ﺑﺨﻮاهﻴﻢ دﻓﻌﻪ ي ﺑﻌﺪ آﻪ ﺑﺮﻧﺎﻣﻪ ﺗﻮﺳﻂ آﺎرﺑﺮ اﺟﺮا ﻣﻲ ﺷﻮد، ﻓﺮم ﺑـﺎ ﻃـﻮل‬ ‫و ﻋﺮض ﺟﺪﻳﺪ )ﻳﻌﻨﻲ هﻤﺎن اﻧﺪاز هﺎي ﺗﻐﻴﻴﺮ ﭘﻴﺪا آﺮدﻩ ﺗﻮﺳﻂ آﺎرﺑﺮ( ﻧﻤﺎﻳﺶ دادﻩ ﺷﻮد.‬ ‫دﺳﺘﻮرات زﻳﺮ، ﻣﻘﺪار ﻃﻮل و ﻋﺮض ﺗﻐﻴﻴﺮ ﻳﺎﻓﺘﻪ ي ﻓﺮم را در رﺟﻴﺴﺘﺮي ذﺧﻴﺮﻩ ﻣﻲ آﻨﻨﺪ:‬ ‫)‪SaveSetting(“MyApp”, “Startup”, “Height”,Me.Height‬‬ ‫)‪SaveSetting(“MyApp”, “Startup”, “Width”,Me.Width‬‬ ‫دﻗﺖ آﻨﻴﺪ آﻪ ﺑﻨﺪﻩ ﺟﻬﺖ راﺣﺘﻲ آﺎر، ﻣﻘﺪار ٣ ﭘﺎراﻣﺘﺮ اول اﻳـﻦ دﺳـﺘﻮرات را ﻣﺘﻨﺎﺳـﺐ ﺑـﺎ ﻣﻘـﺪاري‬ ‫آﻪ ﻗﺮار اﺳﺖ ذﺧﻴﺮﻩ ﺷﻮد اﻧﺘﺨﺎب آﺮدم.‬ ‫ﻧﻜﺘﻪ: ﻣﻨﺎﺳﺐ ﺗﺮﻳﻦ ﻣﻜﺎن ﺑﺮاي ﻧﻮﺷﺘﻦ اﻳﻦ آﺪهﺎ، زﻣﺎﻧﻲ اﺳﺖ آﻪ ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﭘﺎﻳـﺎن ﻣـﻲ ﭘـﺬﻳﺮد‬ ‫و ﻣﻨﺎﺳﺒﺘﺮﻳﻦ زﻣﺎن ﺟﻬﺖ ﻓﺮاﺧﻮاﻧﻲ ﺁﻧﻬﺎ، زﻣﺎﻧﻲ اﺳﺖ آﻪ ﺑﺮﻧﺎﻣﻪ ﺁﻏﺎز ﻣـﻲ ﺷـﻮد. )ﺑـﺎ اﺳـﺘﻔﺎدﻩ از‬ ‫ﺗﺎﺑﻊ ‪ GetSetting‬آﻪ در اداﻣﻪ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻩ اﺳﺖ(‬ ‫)] ‪DeleteSetting(appname,section [,key‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ دﻗﻴﻘﺎ ﻋﻜﺲ ﺗﺎﺑﻊ )(‪ SaveSetting‬ﻋﻤﻞ آﺮدﻩ و ﻳﻚ ﻣﻘﺪار از زﻳﺮﺷﺎﺧﻪ ﻳﺎ آـﻞ زﻳﺮﺷـﺎﺧﻪ‬ ‫را از رﺟﻴﺴﺘﺮي ﺧﺬف ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن هﺎي اﻳﻦ ﺗﺎﺑﻊ، هﻤﺎن ﺁرﮔﻮﻣﺎن هﺎي ﺗﺎﺑﻊ )(‪ SaveSetting‬هﺴﺘﻨﺪ.‬ ‫اﮔـﺮ از ذآـﺮ ﺁرﮔﻮﻣـﺎن اﺧﺘﻴـﺎري ‪ key‬ﺧـﻮدداري ﺷـﻮد، ﺗﻤـﺎﻣﻲ ﻣﻘـﺎدﻳﺮ ﻣﻮﺟـﻮد در زﻳﺮﺷـﺎﺧﻪ ﺣـﺬف‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ﺧﻮاهﻨﺪ ﺷﺪ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻣﻲ ﺧﻮاهﻴﻢ ﻣﻘﺎدﻳﺮي را آﻪ در ﻣﺜﺎل ﺗﺎﺑﻊ )(‪ SaveSetting‬در رﺟﻴـﺴﺘﺮي ذﺧﻴـﺮﻩ‬ ‫آﺮدﻳﻢ، ﺣﺬف آﻨﻴﻢ. ﭘﺲ دﺳﺘﻮرات زﻳﺮ را ﻣﻲ ﻧﻮﻳﺴﻴﻢ:‬ ‫)”‪DeleteSetting(“MyApp”, “Startup”, “Height‬‬ ‫)”‪DeleteSetting(“MyApp”, “Startup”, “Width‬‬ ‫ﻣﻲ ﺗﻮاﻧﻴﺪ اﻳﻦ دﺳﺘﻮرات را در ﻳﻚ ﺧﻂ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺧﻼﺻﻪ آﻨﻴﺪ:‬ ‫)”‪DeleteSetting(“MyApp”, Startup‬‬ ‫دﻗﺖ آﻨﻴﺪ اﮔﺮ ﻣﻘﺎدﻳﺮ دﻳﮕﺮي ﻧﻴﺰ در زﻳﺮﺷﺎﺧﻪ ي ‪ Startup‬وﺟﻮد داﺷـﺘﻪ ﺑﺎﺷـﻨﺪ، ﺁﻧﻬـﺎ ﻧﻴـﺰ ﺣـﺬف‬ ‫ﻣﻲ ﺷﻮﻧﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٧٥‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 58.
    ‫)] ‪GetSetting(appname,section,key [,default‬‬ ‫وﻗﺘﻲ آﻪ ﻣﻘﺎدﻳﺮ در رﺟﻴﺴﺘﺮي ﻧﻮﺷﺘﻪ ﺷﺪ ﻃﺒﻌﺎ ﺑﺎﻳﺪ ﺁﻧﻬﺎ را ﺧﻮاﻧﺪ.‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻣﻘﺪار ذﺧﻴﺮﻩ ﺷﺪﻩ ي آﺎرﺑﺮ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫٣ ﺁرﮔﻮﻣﺎن اول اﻳﻦ ﺗﺎﺑﻊ هﻤﺎن ﭘﺎراﻣﺘﺮهﺎي ﺗﻮاﺑﻊ )(‪ SaveSetting‬و )(‪ DeleteSetting‬هـﺴﺘﻨﺪ‬ ‫آﻪ ﻣﺴﻴﺮ ذﺧﻴﺮﻩ دادﻩ در رﺟﻴﺴﺘﺮي را ﻣﺸﺨﺺ ﻣﻲ آﻨﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،default‬ﻣﻘﺪاري ﭘـﻴﺶ ﻓـﺮض اﺳـﺖ آـﻪ در ﺻـﻮرت ﻧﺒـﻮدن ﻣﻘـﺪاري در ﻣـﺴﻴﺮ‬ ‫ذآﺮﺷﺪﻩ، ﺗﻮﺳﻂ ﺗﺎﺑﻊ ﺑﺮﮔﺸﺖ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻣﻲ ﺧﻮاهﻴﻢ ﻣﻘﺎدﻳﺮي را آﻪ در ﻣﺜﺎل ﺗﺎﺑﻊ )(‪ SaveSetting‬در رﺟﻴـﺴﺘﺮي ذﺧﻴـﺮﻩ‬ ‫آﺮدﻳﻢ، ﺑﻪ دﺳﺖ ﺁوردﻩ و ﻃﻮل و ﻋﺮض ﺟﺪﻳﺪ ﻓﺮم را در هﻨﮕﺎم اﺟﺮاي ﺑﺮﻧﺎﻣﻪ ﺗﻌﻴﻴﻦ آﻨﻴﻢ:‬ ‫)0001 ,”‪Me.Height =GetSetting(“MyApp”, “Startup”, “Height‬‬ ‫)0051 ,”‪Me.Width =GetSetting(“MyApp”, “Startup”, “Width‬‬ ‫در اﻳﻦ دﺳﺘﻮرات ﺣﺘﻤﺎ ﺑﺎﻳﺪ ﻣﻘﺪار ﺁرﮔﻮﻣﺎن ‪ default‬را ذآﺮ آﻨﻴﺪ ﭼـﻮن در ﺻـﻮرﺗﻲ آـﻪ ﻣﻘـﺪاري در‬ ‫رﺟﻴﺴﺘﺮي وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ، ﻓﺮم ﻣﻤﻜﻦ اﺳﺖ ﺑﺎ ﺳﺎﻳﺰي ﺑﺴﻴﺎر آﻮﭼﻚ ﻳﺎ ﺑـﺴﻴﺎر ﺑـﺰرگ ﻇـﺎهﺮ‬ ‫ﺷﻮد.‬ ‫)‪GetAllSettings(appname,section‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻟﻴﺴﺘﻲ از ﺗﻤﺎﻣﻲ ﻣﻘﺎدﻳﺮ ﻣﻮﺟﻮد در زﻳﺮﺷـﺎﺧﻪ ﺗﻌﻴـﻴﻦ ﺷـﺪﻩ را ﺑـﺎ ﻗـﺮار دادن ﺁﻧﻬـﺎ در ﻳـﻚ‬ ‫ﺁراﻳﻪ ي دو ﺑﻌﺪي ﺑﺮﻣﻲ ﮔﺮداﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن هﺎي ‪ appname‬و ‪ section‬ﻗﺒﻼ ﺗﻮﺿﻴﺢ دادﻩ ﺷﺪﻧﺪ.‬ ‫ﺧﺎﻧﻪ ي )0,0( ﺁراﻳﻪ، ﻧﺎم اوﻟﻴﻦ ﻣﻘﺪار زﻳﺮﺷـﺎﺧﻪ و ﺧﺎﻧـﻪ ي )1,0( ﺁراﻳـﻪ، ﻣﻘـﺪار ﺁن را در ﺧـﻮد ﻧﮕـﻪ‬ ‫ﻣﻲ دارد.‬ ‫ﺧﺎﻧﻪ ي )0,1( ﺁراﻳﻪ، ﻧﺎم دوﻣﻴﻦ ﻣﻘﺪار زﻳﺮﺷﺎﺧﻪ و ﺧﺎﻧﻪ ي )1,1( ﺁراﻳﻪ، ﻣﻘﺪار ﺁن را ﻧﮕﻬﺪاري ﻣـﻲ‬ ‫آﻨﺪ و ﺑﻪ هﻤﻴﻦ ﺗﺮﺗﻴﺐ…‬ ‫ﻧﻜﺘﻪ: ﺑﺮاي ﺁﮔﺎهﻲ از ﺗﻌﺪاد ﻣﻘﺎدﻳﺮ ذﺧﻴﺮﻩ ﺷﺪﻩ در ﺁراﻳﻪ ﻳﺎ ﺑﻪ ﻋﺒﺎرت ﺑﻬﺘﺮ ﺗﻌﺪاد ﻣﻘـﺎدﻳﺮ ﻣﻮﺟـﻮد در‬ ‫زﻳﺮﺷﺎﺧﻪ، از ﺧﺎﺻﻴﺖ ‪ Length‬ﺁراﻳﻪ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫ﻓﺮض ﻣﻲ آﻨﻴﻢ ﺁراﻳﻪ ‪ AllSettings‬ﺑﻪ ﻋﻨﻮان ﻳﻚ ﺁراﻳﻪ دو ﺑﻌﺪي ﻣﻌﺮﻓﻲ ﺷﺪﻩ اﺳﺖ.‬ ‫دﺳ ـﺘﻮر زﻳــﺮ، ﺗﻤــﺎﻣﻲ ﻣﻘــﺎدﻳﺮ ﻣﻮﺟــﻮد در زﻳــﺮ ﺷــﺎﺧﻪ ي ‪ Startup‬از ﺷــﺎﺧﻪ ‪ MyApp‬را در ﺁراﻳــﻪ‬ ‫ـ‬ ‫‪ AllSettings‬ﻗﺮار ﻣﻲ دهﺪ.‬ ‫)”‪AllSettings = GetAllSettings(“MyApp”, “Startup‬‬ ‫ﺣﺎﻻ ﻣﻲ ﺗﻮاﻧﻴﻢ ﺑﺎ دﺳﺘﻮرات زﻳﺮ، ﺗﻤﺎﻣﻲ ﻣﻘﺎدﻳﺮ ﻣﻮﺟﻮد در زﻳﺮﺷﺎﺧﻪ را آـﻪ در ﺁراﻳـﻪ ذﺧﻴـﺮﻩ ﺷـﺪﻩ‬ ‫اﻧﺪ را ﺑﺒﻴﻨﻴﻢ:‬ ‫)0(‪For i =0 To AllSettings.GetUpperBound‬‬ ‫))1,‪Console.WriteLine(AllSettings(i,0) & “ = “ & AllSettings(i‬‬ ‫‪Next‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٨٥‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 59.
    ‫)‪:(Application Collaboration‬‬ ‫ﺗﻮاﺑﻊ آﺎرﺑﺮدي‬ ‫)] ‪Shell(path_name [,style ][,wait ][,timeout‬‬ ‫ﺑﺎ اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ، ﻗﺎدر ﺑﻪ اﺟﺮاي ﻳﻚ ﺑﺮﻧﺎﻣﻪ دﻳﮕﺮ از درون ﺑﺮﻧﺎﻣﻪ ي ﺧﻮد هﺴﺘﻴﺪ.‬ ‫در ﺻﻮرﺗﻲ آﻪ اﻳﻦ ﺗﺎﺑﻊ آﺎر ﺧﻮد را ﺑﺎ ﻣﻮﻓﻘﻴﺖ اﻧﺠﺎم دهﺪ، هﻨﺪل ﺑﺮﻧﺎﻣﻪ ي اﺟﺮا ﺷﺪﻩ را آﻪ ﺗﻮﺳـﻂ‬ ‫ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ در ﻏﻴﺮ اﻳﻨﺼﻮرت، ﻣﻘﺪار ﺻﻔﺮ را ﺑﺮﮔـﺸﺖ ﻣـﻲ‬ ‫دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،path_name‬ﻣﺴﻴﺮ و ﻧﺎم ﻓﺎﻳﻠﻲ اﺳﺖ آﻪ ﻣﻲ ﺧﻮاهﻴﻢ اﺟﺮا ﺷﻮد. اﮔـﺮ ﻓﺎﻳـﻞ اﺟﺮاﻳـﻲ‬ ‫ﻧﻴﺎز ﺑﻪ ﺁرﮔﻮﻣﺎن هﺎﻳﻲ هﻤﺎﻧﻨﺪ ‪ command‬هﺎي ﻣﺨﺼﻮص ﺧﻮد داﺷﺖ، ﻣﻲ ﺗﻮان ﻧـﺎم ﺁﻧﻬـﺎ را ﻧﻴـﺰ‬ ‫در اداﻣﻪ ﻣﺴﻴﺮ ﻓﺎﻳﻞ ذآﺮ آﺮد آﻪ اﻳﻦ ﻣﻮرد ﻣﻌﻤﻮﻻ ﻧﺪرﺗﺎ وﺟﻮد دارد.‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: اﻳﻦ ﺗﺎﺑﻊ ﺗﻨﻬﺎ ﻓﺎﻳﻞ هﺎي اﺟﺮاﻳﻲ را اﺟﺮا ﻣﻲ آﻨﺪ اﻣـﺎ ﻣـﻲ ﺗـﻮان ﺑـﺎ ﻧـﺴﺒﺖ دادن ﻧـﺎم و‬ ‫ﻣﺴﻴﺮ ﻓﺎﻳﻠﻲ دﻳﮕﺮ در اداﻣﻪ ﻧﺎم و ﻣﺴﻴﺮ ﻓﺎﻳﻞ اﺻﻠﻲ، در ﺻﻮرﺗﻲ آﻪ اﻳﻦ ﻓﺎﻳﻞ ﺑﺎ ﺑﺮﻧﺎﻣـﻪ ﻣـﻮرد ﻧﻈـﺮ‬ ‫ﻣﺎ ﻗﺎﺑﻞ اﺟﺮا ﺑﺎﺷﺪ، ﺁن را اﺟﺮا آﺮد ﻣﺜﻼ ﻳﻚ ﻓﺎﻳﻞ ﺑﺎ ﭘﺴﻮﻧﺪ ‪ TXT‬را ﻣـﻲ ﺗـﻮان ﺑـﺎ دﺳـﺘﻮر زﻳـﺮ اﺟـﺮا‬ ‫آﺮد:‬ ‫)‪NTXT=Shell(“notepad.exe C:MyFile.txt”, AppWinStyle.NormalFocus‬‬ ‫اﻳﻦ دﺳﺘﻮر، ﻓﺎﻳﻞ ‪ MyFile.txt‬را ﺑﻪ وﺳﻴﻠﻪ ﺑﺮﻧﺎﻣﻪ ‪ Notepad‬ﺑﺎز ﻣﻲ آﻨﺪ.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ ،style‬وﺿﻌﻴﺖ ﻓﺮم ﺑﺮﻧﺎﻣﻪ اي آﻪ اﺟـﺮا ﺧﻮاهـﺪ ﺷـﺪ را ﻣﻌـﻴﻦ ﻣـﻲ آﻨـﺪ و ﻣـﻲ‬ ‫ﺗﻮاﻧﺪ ﻳﻜﻲ از ﻣﻘﺎدﻳﺮ زﻳﺮ را ﺑﭙﺬﻳﺮد:‬ ‫ﻣﻘﺎدﻳﺮ ﭘﺎراﻣﺘﺮ ‪ Style‬در ﺗﺎﺑﻊ )(‪Shell‬‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻣﻘﺪار‬ ‫ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت ﻣﺨﻔﻲ اﺟﺮا ﻣﻲ ﺷﻮد اﻣﺎ ﺑﻪ ﻋﻨـﻮان ﺑﺮﻧﺎﻣـﻪ ﻓﻌـﺎل‬ ‫‪Hide‬‬ ‫در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮل و ﺑـﺎ اﻧـﺪازﻩ ﺧـﻮدش اﺟـﺮا ﻣـﻲ ﺷـﻮد و ﺑـﻪ‬ ‫‪NormalFocus‬‬ ‫ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌﺎل در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت ﻣﻴﻨﻴﻤﺎﻳﺰ اﺟﺮا ﺧﻮاهﺪ ﺷﺪ و ﺑﻪ ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌـﺎل‬ ‫‪MinimizedFocus‬‬ ‫در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت ﺗﻤﺎم ﺻـﻔﺤﻪ اﺟـﺮا ﻣـﻲ ﺷـﻮد و ﺑـﻪ ﻋﻨـﻮان ﺑﺮﻧﺎﻣـﻪ‬ ‫‪MaximizedFocus‬‬ ‫ﻓﻌﺎل در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد.‬ ‫ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮل و ﺑﺎ اﻧﺪازﻩ ﺧﻮدش اﺟﺮا ﻣـﻲ ﺷـﻮد اﻣـﺎ ﺑـﻪ‬ ‫‪NormalNoFocus‬‬ ‫ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌﺎل در ﻧﻈﺮ ﮔﺮﻓﺘـﻪ ﻧﻤـﻲ ﺷـﻮد و ﺑﺮﻧﺎﻣـﻪ اي آـﻪ ﺑـﻪ‬ ‫ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌﺎل اﺳﺖ، ﻓﻌﺎل ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ.‬ ‫‪ MinimizedNoFocus‬ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت ﻣﻴﻨﻴﻤﺎﻳﺰ اﺟﺮا ﻣﻲ ﺷﻮد اﻣﺎ ﺑﻪ ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌـﺎل‬ ‫در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻧﻤﻲ ﺷﻮد و ﺑﺮﻧﺎﻣـﻪ اي آـﻪ ﺑـﻪ ﻋﻨـﻮان ﺑﺮﻧﺎﻣـﻪ ﻓﻌـﺎل‬ ‫اﺳﺖ، ﻓﻌﺎل ﺑﺎﻗﻲ ﻣﻲ ﻣﺎﻧﺪ.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ wait‬ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ ﺁﻳﺎ ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﺑﺮاي اﺟﺮاي آﺎﻣﻞ ﺑﺮﻧﺎﻣﻪ اي آﻪ ﻓﺮاﺧـﻮاﻧﻲ‬ ‫ﺧﻮاهﺪ ﺷﺪ ﺻﺒﺮ آﻨﺪ ﻳﻌﻨﻲ دﺳﺘﻮرات ﺑﻌـﺪ از ﺗـﺎﺑﻊ )(‪ ،Shell‬ﭘـﺲ از ﻓﺮاﺧـﻮاﻧﻲ ﺑﺮﻧﺎﻣـﻪ ﻣـﻮرد ﻧﻈـﺮ‬ ‫اﺟﺮا ﺷﻮﻧﺪ ﻳﺎ ﺑﻼﻓﺎﺻﻠﻪ.‬ ‫ﺑﻪ ﻋﺒﺎرت ﺳﺎدﻩ ﺗﺮ، ﺗﻌﻴﻴﻦ ﻣﻲ آﻨـﺪ آـﻪ ﻗﺒـﻞ از اﺟـﺮاي ﺗﻤـﺎﻣﻲ دﺳـﺘﻮرات ﺑﻌـﺪ از ﺗـﺎﺑﻊ )(‪،Shell‬‬ ‫ﺑﺮﻧﺎﻣﻪ اﺟﺮا ﺷﻮد ﻳﺎ در هﻤﺎن زﻣﺎن ﻓﺮاﺧﻮاﻧﻲ.‬ ‫اﻳﻦ ﭘﺎراﻣﺘﺮ، ﻣﻘﺪار ‪ True‬ﻳـﺎ ‪ False‬را ﻣـﻲ ﭘـﺬﻳﺮد آـﻪ ﺑـﻪ ﻃـﻮر ﭘـﻴﺶ ﻓـﺮض، ‪ False‬اﺳـﺖ ﻳﻌﻨـﻲ‬ ‫ﺑﺮﻧﺎﻣﻪ اي آﻪ ﻗﺮار اﺳﺖ اﺟﺮا ﺷﻮد ﺑﺎﻳﺪ ﺻﺒﺮ آﻨﺪ ﺗـﺎ ﺗﻤـﺎﻣﻲ دﺳـﺘﻮرات ﺑﻌـﺪ از ﺗـﺎﺑﻊ )(‪ shell‬اﺟـﺮا‬ ‫ﺷﻮﻧﺪ.‬ ‫ﺁﺧﺮﻳﻦ ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري آﻪ ‪ timeout‬ﻧﺎم دارد، ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ ﭘﺲ از ﭼﻨـﺪ ﺛﺎﻧﻴـﻪ ﺑﺮﻧﺎﻣـﻪ اي آـﻪ‬ ‫ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ ﺷﻮد ﺑﺎﻳﺪ اﺟﺮا ﺷﻮد.‬ ‫اﻳﻦ ﻣﻘﺪار، ﻋﺪدي ﺑﺮ ﺣﺴﺐ ﻣﻴﻠﻲ ﺛﺎﻧﻴﻪ اﺳﺖ و هﺮ ٠٠٠١ ﻣﻴﻠﻲ ﺛﺎﻧﻴﻪ، ١ ﺛﺎﻧﻴﻪ اﺳﺖ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٩٥‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 60.
    ‫ﺑﻪ ﻃﻮر ﭘﻴﺶﻓﺮض ﻣﻘﺪار اﻳﻦ ﺁرﮔﻮﻣﺎن، 1- اﺳﺖ ﻳﻌﻨﻲ ﺑﺪون وﻗﻔـﻪ و ﺑﻼﻓﺎﺻـﻠﻪ ﭘـﺲ از ﻓﺮاﺧـﻮاﻧﻲ‬ ‫اﺟﺮا ﻣﻲ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل، ﺑﺮاي اﺟﺮاي ﺑﺮﻧﺎﻣﻪ ‪ Notepad‬وﻳﻨﺪوز از دﺳﺘﻮر زﻳﺮ اﺳﺘﻔﺎدﻩ آﻨﻴﺪ:‬ ‫)‪NPAD = Shell(“notepad.exe”, AppWinStyle.NormalFocus‬‬ ‫ﺗﻮﺟﻪ: ﺑﺮاي اﺟﺮاي ﺑﺮﻧﺎﻣﻪ هﺎﻳﻲ آﻪ در ﭘﻮﺷﻪ اﺻﻠﻲ وﻳﻨﺪوز هـﺴﺘﻨﺪ، ﻧﻴـﺎزي ﺑـﻪ ذآـﺮ ﻣـﺴﻴﺮ ﺁﻧﻬـﺎ‬ ‫ﻧﻴﺴﺖ و ﺗﻨﻬﺎ ﺁوردن ﻧﺎم، آﻔﺎﻳﺖ ﻣﻲ آﻨﺪ.‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: ﺗﺎﺑﻊ )(‪ SendKeys‬در ‪ VB.NET‬وﺟﻮد ﻧﺪارد.‬ ‫)] ‪AppActivate(title [,wait‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ )آﻪ ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ ﻧﺪارد( ﺑﻪ ﺷﻤﺎ اﺟﺎزﻩ ﻣـﻲ دهـﺪ ﺑﺮﻧﺎﻣـﻪ اي را آـﻪ ﻗـﺒﻼ ﺗﻮﺳـﻂ ﺗـﺎﺑﻊ‬ ‫)(‪ Shell‬ﻓﺮاﺧﻮاﻧﻲ و اﺟﺮا آﺮدﻩ اﻳﺪ، ﺑﻪ ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌﺎل )ﭘﻨﺠﺮﻩ ﻓﻌﺎل( ﺳﻴﺴﺘﻢ ﻋﺎﻣـﻞ ﻣﻌﺮﻓـﻲ‬ ‫آﻨﻴﺪ.‬ ‫در ﺁرﮔﻮﻣﺎن ‪ ،title‬آﻪ ﻣﻘﺪاري از ﻧﻮع رﺷﺘﻪ اي اﺳﺖ ﺑﺎﻳﺪ ﻧﺎم ﻧﻮار ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ اي آﻪ ﻗـﺼﺪ ﻓﻌـﺎل‬ ‫ﺷﺪن ﺁن را دارﻳﺪ ذآﺮ آﻨﻴﺪ. ﻣﺜﻼ: "‪“Untitled – Notepad‬‬ ‫در اﻳﻦ ﺁرﮔﻮﻣﺎن هﻤﭽﻨﻴﻦ ﺑﺎ ذآﺮ آﺮدن ﻣﻘﺪاري آﻪ ﺗـﺎﺑﻊ )(‪ Shell‬در ﻣﺘﻐﻴـﺮ ﻓﺮاﺧـﻮاﻧﻲ آﻨﻨـﺪﻩ ﺧـﻮد‬ ‫ﻗﺮار ﻣﻲ دهﺪ، ﻗﺎدر ﺑﻪ ﻓﻌﺎل آﺮدن ﺑﺮﻧﺎﻣﻪ هﺴﺘﻴﺪ. ﻣﺜﻼ در ﺁﺧﺮﻳﻦ ﻣﺜـﺎل ﺗﻮﺿـﻴﺤﺎت ﺗـﺎﺑﻊ )(‪،Shell‬‬ ‫ﻣﻲ ﺗﻮاﻧﻴﺪ ﻧﺎم ﻣﺘﻐﻴﺮ ‪ NPAD‬را در ﺁرﮔﻮﻣﺎن ‪ title‬اﻳﻦ ﺗﺎﺑﻊ ذآﺮ آﻨﻴﺪ.‬ ‫ﺁرﮔﻮﻣﺎن اﺧﺘﻴﺎري ‪ wait‬ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ ﺁﻳﺎ ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﺑﺎﻳـﺪ ﺑـﻪ ﻋﻨـﻮان ﺑﺮﻧﺎﻣـﻪ ﻓﻌـﺎل ﺑﺎﺷـﺪ ﺗـﺎ‬ ‫ﺑﺘﻮاﻧﺪ ﺑﺮﻧﺎﻣﻪ دﻳﮕﺮي را ﺑﺎ اﻳﻦ ﺗﺎﺑﻊ ﻓﻌﺎل آﻨﺪ ﻳﺎ ﺧﻴﺮ.‬ ‫اﻳﻦ ﭘﺎراﻣﺘﺮ، ﻣﻘﺪار ‪ True‬ﻳﺎ ‪ False‬را ﻣﻲ ﭘﺬﻳﺮد. ﻣﻘﺪار ﭘﻴﺶ ﻓﺮض، ‪ False‬اﺳﺖ ﻳﻌﻨـﻲ ﺣﺘـﻲ در‬ ‫ﺻﻮرت ﻓﻌﺎل ﻧﺒﻮدن ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﻧﻴﺰ، ﺑﺮﻧﺎﻣﻪ درﺧﻮاﺳﺘﻲ ﺑﻪ ﺳﺮﻋﺖ ﻓﻌﺎل ﻣﻲ ﺷﻮد.‬ ‫در ﺻﻮرﺗﻲ آﻪ ‪ True‬ﺑﺎﺷﺪ، ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﺑﺎﻳﺪ ﺻﺒﺮ آﻨﺪ ﺗﺎ ﻓﻌـﺎل ﺷـﻮد ﻳـﺎ اﺻـﻄﻼﺣﺎ ﻓﻮآـﺎس ﺑـﻪ ﺁن‬ ‫اﻧﺘﻘﺎل ﭘﻴﺪا آﻨﺪ ﺗﺎ ﺑﺘﻮاﻧﺪ ﺑﺮﻧﺎﻣﻪ دﻳﮕﺮي را ﻓﻌﺎل آﻨﺪ.‬ ‫ﺗﻮﺟﻪ: اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﻣﻴﻨﻴﻤﺎﻳﺰ ﺑﻮدن ﻳﺎ اﻧﺪازﻩ ي ﭘﻨﺠﺮﻩ هﺎ آﺎري ﻧﺪارد و ﻣﺜﻼ اﮔـﺮ ﺑﺮﻧﺎﻣـﻪ اي ﻣﻴﻨﻴﻤـﺎﻳﺰ‬ ‫ﺑﺎﺷﺪ، ﺁن را در هﻤﺎن ﺣﺎﻟﺖ ﻣﻴﻨﻴﻤﺎﻳﺰ ﺑﻪ ﻋﻨﻮان ﺑﺮﻧﺎﻣﻪ ﻓﻌﺎل در ﻧﻈﺮ ﻣﻲ ﮔﻴﺮد.‬ ‫ﻧﻜﺘﻪ ﻣﻬﻢ: هﻤﻴﺸﻪ ﺳﻌﻲ آﻨﻴﺪ اﺑﺘﺪا ﺑﺮﻧﺎﻣﻪ ﻣﻮرد ﻧﻈﺮ را ﺑﺎ ﺗﺎﺑﻊ )(‪ Shell‬اﺟـﺮا و ﺳـﭙﺲ ﻣﺘﻐﻴـﺮي‬ ‫آﻪ ﺗﺎﺑﻊ )(‪ Shell‬را در ﺁن ﻗﺮار دادﻩ اﻳﺪ در ﺁرﮔﻮﻣﺎن ‪ title‬اﻳﻦ ﺗﺎﺑﻊ ﻗﺮار دادﻩ و اﻗﺪام ﺑﻪ ﻓﻌـﺎل آـﺮدن‬ ‫ﺁن آﻨﻴﺪ. ﻣﺜﻼ ﻓﺮض آﻨﻴﺪ آﻪ ﺑﺮﻧﺎﻣﻪ ‪ Notepad‬را ٢ ﺑﺎر اﺟﺮا آﺮدﻩ اﻳـﺪ و ﻋﻨـﻮان ﻧـﻮار هـﺮ دو ﭘﻨﭽـﺮﻩ‬ ‫‪ ،Notepad‬ﻳﻜﻲ اﺳﺖ. در اﻳﻦ ﺣﺎﻟﺖ اﮔﺮ ﻧﺎم ﻧﻮار ﻋﻨﻮان را در ﺗـﺎﺑﻊ )(‪ AppActivate‬ذآـﺮ آﻨﻴـﺪ،‬ ‫ﺁن ﻳﻜﻲ آﻪ ﺁﺧﺮ اﺟﺮا ﺷﺪﻩ اﺳﺖ ﺑﻪ ﻋﻨﻮان ﭘﻨﺠﺮﻩ ﻓﻌﺎل در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد آـﻪ ﻣﻤﻜـﻦ اﺳـﺖ‬ ‫دﻟﺨﻮاﻩ ﺷﻤﺎ ﻧﺒﺎﺷﺪ.‬ ‫دﺳﺘﻮرات اﺧﺘﻴﺎري )‪:(Option Statements‬‬ ‫دﺳﺘﻮرات ‪ Option‬ﻳﺎ اﺧﺘﻴﺎري، ﺳﻬﻮﻟﺖ آﺎر در آﺪﻧﻮﻳﺴﻲ را ﺑﺮاي ﺷﻤﺎ ﻓﺮاهﻢ ﻣﻲ آﻨﻨﺪ.‬ ‫اﻳﻦ دﺳﺘﻮرات در اﺑﺘﺪاي آﺪ ﻓﺮم ﻳﺎ ﻣـﺎژول ﻧﻮﺷـﺘﻪ ﻣـﻲ ﺷـﻮﻧﺪ و در ﺗﻤـﺎم ﺁن ﻓـﺮم ﻳـﺎ ﻣـﺎژول ﻗﺎﺑـﻞ‬ ‫دﺳﺘﺮﺳﻲ هﺴﺘﻨﺪ. اﻳﻦ دﺳﺘﻮرات را در زﻳﺮ ﻣﺸﺎهﺪﻩ ﻣﻲ آﻨﻴﺪ:‬ ‫‪Option Compare‬‬ ‫اﻳﻦ دﺳﺘﻮر ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ آﻪ ‪ VB‬ﭼﮕﻮﻧﻪ ﻋﻤﻠﻴﺎت ﻣﻘﺎﻳﺴﻪ اي رﺷﺘﻪ هﺎ را اﻧﺠﺎم دهﺪ.‬ ‫ﻣﻘﺎﻳﺴﻪ ي رﺷﺘﻪ اي ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ ﻃﻮر ﻣﻌﻤﻮل ﻳﺎ ﺑﺎ در ﻧﻈﺮ ﮔﺮﻓﺘﻦ ﺑـﺰرگ ﻳـﺎ آﻮﭼـﻚ ﺑـﻮدن ﺣـﺮوف‬ ‫اﻧﺠﺎم ﺷﻮد.‬ ‫ﻣﻘﺎﻳﺴﻪ رﺷﺘﻪ اي ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ ﻳﻜﻲ از دو ﺷﻜﻞ زﻳﺮ ﺻﻮرت ﭘﺬﻳﺮد:‬ ‫‪ :Option Compare Binary‬در اﻳــﻦ ﻧــﻮع ﻣﻘﺎﻳــﺴﻪ آــﻪ ﺑــﻪ ﺻــﻮرت ﺑــﺎﻳﻨﺮي اﻧﺠــﺎم ﻣــﻲ ﺷــﻮد،‬ ‫آﺎراآﺘﺮهﺎي ﺑﺰرگ ﺑﺮ آﺎراآﺘﺮهﺎي آﻮﭼﻚ ارﺟﻌﻴﺖ دارﻧـﺪ و آﺎراآﺘﺮهـﺎي ‪ Symbol‬ﻳـﺎ ﻧﻤـﺎد در اﻧﺘﻬـﺎ‬ ‫ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ. ﻣﺜﻼ ﺑﻪ ﺷﻜﻞ زﻳﺮ:‬ ‫^‪A < B < C… < Z < a < b < c… < z < A’ < A^ < a’ < a‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٠٦‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 61.
    ‫‪ :Option CompareText‬در اﻳﻦ ﻧﻮع ﻣﻘﺎﻳﺴﻪ، ﻋﻤﻞ ﻣﻘﺎﻳﺴﻪ ﺑـﺎ ﺗﻮﺟـﻪ ﺑـﻪ ﺑـﺰرگ و آﻮﭼـﻚ ﺑـﻮدن‬ ‫ﺣﺮوف اﻧﺠﺎم ﻣﻲ ﺷﻮد. اﻳﻦ ﻧﻮع ﻣﻘﺎﻳﺴﻪ، ﻣﻘﺎﻳﺴﻪ ﭘﻴﺶ ﻓﺮض رﺷﺘﻪ هﺎ اﺳﺖ. ﻣﺜﻼ:‬ ‫‪A=a < A'=a' < B=b‬‬ ‫‪Option Explicit‬‬ ‫هﻤﺎن ﻃﻮر آﻪ ﻣﻲ داﻧﻴﺪ، در ‪ VB‬ﻣﻲ ﺗﻮان ﻳﻚ ﻣﺘﻐﻴﺮ را ﺑﺪون ﺗﻌﺮﻳﻒ آﺮدن ﺁن ﺑﻪ آﺎر ﺑﺮد.‬ ‫ﻣﻲ ﺗﻮان ﺑﺎ اﺳﺘﻔﺎدﻩ از اﻳﻦ دﺳﺘﻮر ﺑﻪ آﺎﻣﭙﺎﻳﻠﺮ وﻳﮋوال ﺑﻴﺴﻴﻚ ﮔﻔﺖ آﻪ از ﺗﻌﺮﻳـﻒ ﻧﻜـﺮدن ﻣﺘﻐﻴﺮهـﺎ‬ ‫در ﻃﻮل ﻓﺮم ﻳﺎ ﻣﺎژوﻟﻲ آﻪ اي دﺳﺘﻮر ﻗﺮار ﻣﻲ ﮔﻴﺮد، ﺟﻠﻮﮔﻴﺮي آﻨﺪ.‬ ‫در اﻳﻦ ﺣﺎﻟﺖ، در زﻣﺎن اﺟﺮاي ﺑﺮﻧﺎﻣﻪ آﺎﻣﭙﺎﻳﻠﺮ ‪ VB‬ﺗﻤـﺎﻣﻲ ﻣﺘﻐﻴﺮهـﺎ را از ﻟﺤـﺎظ ﺗﻌﺮﻳـﻒ ﺷـﺪن ﭼـﻚ‬ ‫ﻣﻲ آﻨﺪ و در ﺻﻮرﺗﻲ آﻪ هﺮ ﻳﻚ ار ﺁﻧﻬﺎ ﺗﻌﺮﻳﻒ ﻧﺸﺪﻩ ﺑﺎﺷﻨﺪ، ﺑﻪ ﺷﻤﺎ اﺧﻄﺎر ﻣﻲ دهﺪ.‬ ‫ﻣﻲ ﺗﻮاﻧﻴﺪ ﺑﺎ ﻓﻌﺎل آﺮدن اﻳﻦ ﮔﺰﻳﻨﻪ در ﺳﺮﺑﺮگ ‪ Build‬از ﻗﺴﻤﺖ ‪ Project Property Pages‬در‬ ‫‪ ،VB.NET‬ﺑﻪ ﻃﻮر ﺧﻮدآﺎر در ﺗﻤﺎﻣﻲ ﻓﺮم هﺎ و ﻣﺎژول هﺎي ﺑﺮﻧﺎﻣﻪ اﻳﻦ دﺳﺘﻮر را ﻓﻌﺎل آﻨﻴﺪ.‬ ‫ﺗﻮﺟﻪ: در ﺻﻮرﺗﻲ آﻪ در ‪ ،VB.NET‬ﻧﻮع ﻣﺘﻐﻴﺮ ﺗﻌﺮﻳﻒ ﻧﺸﻮد ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض از ﻧـﻮع ‪ Object‬در‬ ‫ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد. )در 0.6.‪ VB‬از ﻧﻮع ‪ Variant‬در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﺪ(‬ ‫‪Option Strict‬‬ ‫هﻤﺎن ﻃﻮر آﻪ اﺷﺎرﻩ ﺷﺪ در ﺻﻮرﺗﻲ آﻪ ﻧﻮع ﻣﺘﻐﻴﺮي در ‪ VB.NET‬ذآﺮ ﻧﺸﻮد، ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض‬ ‫از ﻧﻮع ‪ Object‬در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد و در هﻨﮕﺎم ﻣﻘﺪاردهﻲ ﺑـﻪ ﺁن ﻣﺘﻐﻴـﺮ، ﻧـﻮع ﺁن ﺑـﻪ ﺻـﻮرت‬ ‫ﺧﻮدآﺎر ﺗﻮﺳﻂ ‪ VB‬ﺗﻌﻴﻴﻦ ﻣﻲ ﺷﻮد.‬ ‫دﺳﺘﻮرات زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫‪Dim MyVar‬‬ ‫”‪MyVar=”Hello World‬‬ ‫در دﺳﺘﻮرات ﻓﻮق اﺑﺘﺪا ﻳﻚ ﻣﺘﻐﻴـﺮ ﺑـﺪون ﻧـﻮع ﺗﻌﺮﻳـﻒ ﻣـﻲ ﺷـﻮد آـﻪ ﺑـﻪ ﻃـﻮر ﭘـﻴﺶ ﻓـﺮض از ﻧـﻮع‬ ‫‪ Object‬در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد و ﺳﭙﺲ در هﻨﮕﺎم ﻣﻘﺪاردهﻲ ﺑﻪ ﺁن، ‪ VB‬ﺑﻪ ﻃـﻮر ﺧﻮدآـﺎر ﻧـﻮع‬ ‫ﻣﻘﺪار ﻧﺴﺒﺖ دادﻩ ﺷﺪﻩ را ﺗﺸﺨﻴﺺ و ﺁن را ﺗﺒﺪﻳﻞ ﺑﻪ ﺁن ﻧﻮع ﻣـﻲ آﻨـﺪ آـﻪ در ﻣﺜـﺎل ﻓـﻮق از ﻧـﻮع‬ ‫‪ String‬در ﻧﻈﺮ ﻣﻲ ﮔﻴﺮد.‬ ‫ﭼﻨﺎﻧﭽﻪ ﻣﺎﻳﻞ هﺴﺘﻴﺪ آﻪ ﻋﻤﻞ ﺗﺒﺪﻳﻞ ﺧﻮآﺎر ﻧﻮع ﻣﺘﻐﻴﺮ ﺗﻌﺮﻳـﻒ ﻧـﺸﺪﻩ ﺗﻮﺳـﻂ ‪ VB‬اﻧﺠـﺎم ﻧـﺸﻮد و‬ ‫هﻤـﺎن ﻣﻘـﺪار ‪ Object‬در ﻧﻈـﺮ ﮔﺮﻓﺘـﻪ ﺷـﻮد، دﺳـﺘﻮر ‪ Option Strict‬را در اوﻟـﻴﻦ ﺧـﻂ آـﺪ ﻓـﺮم‬ ‫ـ ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ﺑﻨﻮﻳﺴﻴﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫١٦‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 62.
    ‫)‪:(Miscellaneous‬‬ ‫ﺗﻮاﺑﻊ ﻣﺘﻔﺮﻗﻪ‬ ‫ﺗﻮاﺑﻌﻲ هﺴﺘﻨﺪ آﻪ ﻧﻤﻲ ﺗﻮان ﺁﻧﻬﺎ را در هﻴﭻ ﮔﺮوهﻲ دﺳﺘﻪ ﺑﻨﺪي آﺮد.‬ ‫اﻳﻦ ﺗﻮاﺑﻊ در اﻳﻦ ﻗﺴﻤﺖ ﻣﻮرد ﺑﺤﺚ ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ.‬ ‫)]...,2‪Choose(index,choice1 [,choice‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻣﻘﺪاري را از ﻳﻚ ﺳﺮي ﺁرﮔﻮﻣﺎن، اﻧﺘﺨﺎب و ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،index‬ﻳﻚ ﻣﻘـﺪار ﻋـﺪدي ﺑـﻴﻦ ١ ﺗـﺎ ﺗﻌـﺪاد ﺁرﮔﻮﻣـﺎن هـﺎي ‪ Choice‬اﺳـﺖ آـﻪ ﻧﻤﺎﻳـﺎﻧﮕﺮ‬ ‫ﺷﻤﺎرﻩ ﺁرﮔﻮﻣﺎﻧﻲ اﺳﺖ آﻪ ﻣﻲ ﺧﻮاهﻴﻢ ﺑﺮﮔﺸﺖ دادﻩ ﺷﻮد.‬ ‫ﺁرﮔﻮﻣﺎن هـﺎي 1‪ choice2 ،choice‬و…، ﻟﻴـﺴﺘﻲ از ﺁرﮔﻮﻣـﺎن هـﺎﻳﻲ هـﺴﺘﻨﺪ آـﻪ ﻣـﻲ ﺧـﻮاهﻴﻢ‬ ‫ﻣﻘﺪاري را از ﺁﻧﻬﺎ اﻧﺘﺨﺎب و ﺑﺮﮔﺸﺖ دهﻴﻢ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜـﺎل، اﮔـﺮ ﻣﻘـﺪار ‪ ١ ،index‬ﺑﺎﺷـﺪ ﻣﻘـﺪار ﺑﺮﮔـﺸﺘﻲ، ﻣﻘـﺪار ﺁرﮔﻮﻣـﺎن 1‪ choice‬و اﮔـﺮ‬ ‫‪ ٢ ،index‬ﺑﺎﺷﺪ، ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ ﺗﺎﺑﻊ، ﻣﻘﺪار ﺁرﮔﻮﻣﺎن 2‪ choice‬و ﺑﻪ هﻤﻴﻦ ﺗﺮﺗﻴﺐ ﺧﻮاهﺪ ﺑﻮد.‬ ‫ﻣﺜﻼ ﻳﻜﻲ از آﺎرﺑﺮدهﺎي اﻳﻦ ﺗﺎﺑﻊ ﺑﺮاي ﺑﺮﮔﺸﺖ ﻣﻌﺎدل ﺣﺮﻓﻲ اﻋﺪاد ﺗﻚ رﻗﻤﻲ اﺳﺖ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل، ﺗﺎﺑﻊ زﻳﺮ آﻪ )(‪ IntToString‬ﻧﺎم دارد، ﻧﺎم ﻣﻌﺎدل ﻋﺪدي آﻪ ﺑﻪ ﺁن دادﻩ ﻣﻲ ﺷـﻮد‬ ‫را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ:‬ ‫‪Function IntToString(int As Integer)As String‬‬ ‫_ , ”‪IntToString =Choose (int + 1, “zero”, “one”, “two”, “three‬‬ ‫)”‪“four”, “five”, “six”, “seven”, “eight”, “nine‬‬ ‫‪End Function‬‬ ‫دﺳﺘﻮر زﻳﺮ ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ ﺑﺎﻻ، ﻣﻘﺪار ﺣﺮﻓﻲ ﻣﻌﺎدل ﻋـﺪد ٨ را ﺑﺮﮔﺮداﻧـﺪﻩ و ﺑـﺎ اﺳـﺘﻔﺎدﻩ از ﺗـﺎﺑﻊ‬ ‫)(‪ MsgBox‬ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ:‬ ‫))8(‪MsgBox(IntToString‬‬ ‫ﺗﻮﺟﻪ: در ﺻﻮرﺗﻲ آﻪ ﻣﻘﺪار ﺁرﮔﻮﻣﺎن ‪ index‬از ١ آﻤﺘﺮ ﻳﺎ ﻣﻘﺪار ﺁن از ﺗﻌﺪاد ﺁرﮔﻮﻣﺎن هـﺎي ‪choice‬‬ ‫ﺑﻴﺸﺘﺮ ﺑﺎﺷﺪ، ﻣﻘﺪار ﺑﺮﮔﺸﺘﻲ اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ﻣﻘﺪار ‪ Null‬ﺧﻮاهﺪ ﺑﻮد.‬ ‫)‪IIf(expression,truepart,falsepart‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﺷﻜﻞ ﺳﺎدﻩ ﺗﺮ اﺳﺘﻔﺎدﻩ از ﺳﺎﺧﺘﺎر ﺗﺼﻤﻴﻢ ﮔﻴﺮي ‪ If Then Else‬اﺳﺖ.‬ ‫ﻣﻌﺎدل ﺳﺎﺧﺘﺎر ‪ If Then Else‬اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺖ:‬ ‫‪If expression Then‬‬ ‫‪result =truepart‬‬ ‫‪Else‬‬ ‫‪result =falsepart‬‬ ‫‪End If‬‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،expression‬ﻳﻚ ﻋﺒﺎرت ﺷﺮﻃﻲ اﺳﺖ آﻪ درﺳﺖ ﻳﺎ ﻏﻠﻂ ﺑﻮدن ﺁن ﺑﺎﻳﺪ ﭼﻚ ﺷﻮد.‬ ‫اﮔ ـﺮ ﻋﺒ ـﺎرت ﺷ ـﺮﻃﻲ ﻣﻮﺟ ـﻮد در ‪ ،expression‬ﺻ ـﺤﻴﺢ ﺑﺎﺷ ـﺪ، ﻋﺒ ـﺎرت ‪ truepart‬وﮔﺮﻧ ـﻪ ﻋﺒ ـﺎرت‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫ـ‬ ‫‪ falsepart‬اﺟﺮا ﺧﻮاهﺪ ﺷﺪ.‬ ‫در ﻣﺜﺎل زﻳﺮ، ﭼﻨﺎﻧﭽﻪ ﻣﻘﺪار ‪ A‬از ‪ B‬آﻮﭼﻜﺘﺮ ﺑﺎﺷﺪ، ‪ A‬در ‪ Min‬وﮔﺮﻧﻪ ‪ B‬در ‪ Min‬ﻗﺮار ﻣﻲ ﮔﻴﺮد:‬ ‫)‪Min=Iif(A < B, A, B‬‬ ‫دﺳﺘﻮر زﻳﺮ ﻣﻌﺎدل دﺳﺘﻮر ﻓﻮق اﺳﺖ:‬ ‫‪If A < B Then‬‬ ‫‪Min=A‬‬ ‫‪Else‬‬ ‫‪Min=B‬‬ ‫‪End If‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٢٦‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 63.
    ‫)…,2‪Switch(expression1,value1,expression2,value‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ، ﻟﻴﺴﺘﻲاز ﻋﺒﺎرات ورودي را ﺑﺎ ﻳﻜﺪﻳﮕﺮ ﻣﻘﺎﻳﺴﻪ آﺮدﻩ و ﻣﻘﺪار اوﻟـﻴﻦ ﻋﺒـﺎرﺗﻲ آـﻪ ﺻـﺤﻴﺢ‬ ‫ﺑﺎﺷﺪ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ. در ﺻﻮرﺗﻲ آـﻪ هﻴﭽﻜـﺪام از ﻋﺒـﺎرات ﺻـﺤﻴﺢ ﻧﺒﺎﺷـﻨﺪ، اﻳـﻦ ﺗـﺎﺑﻊ ﻳـﻚ ﻣﻘـﺪار‬ ‫‪ Null‬را ﺑﺮﮔﺸﺖ ﺧﻮاهﺪ داد.‬ ‫ﻣﺜﺎل زﻳﺮ، ﻣﻘﺎدﻳﺮ ﻣﻮﺟـﻮد در ﻣﺘﻐﻴﺮهـﺎي ‪ X‬و ‪ Y‬را ﭼـﻚ آـﺮدﻩ و ﻣﺘﻨﺎﺳـﺐ ﺑـﺎ ﻧـﻮع ﻋﺒـﺎرات ﺷـﺮﻃﻲ‬ ‫ﺗﻌﺮﻳﻒ ﺷﺪﻩ، ﻣﻘﺪاري را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ:‬ ‫)4 ,0<‪Test =Switch(X>0 and Y>0, 1, X<0 and Y>0, 2, X<0 and Y<0, 3, X<0 and Y‬‬ ‫در دﺳﺘﻮر ﻓﻮق ﭼﻨﺎﻧﭽﻪ ‪ X‬و ‪ ،Y‬ﻣﺜﺒﺖ ﺑﺎﺷﻨﺪ ﻣﻘﺪار ١ در ﻣﺘﻐﻴﺮ ‪ Test‬ﻗﺮار ﺧﻮاهﺪ ﮔﺮﻓﺖ.‬ ‫اﮔﺮ ‪ X‬ﻣﺜﺒﺖ و ‪ Y‬ﻣﻨﻔﻲ ﺑﺎﺷﺪ، ﻣﺘﻐﻴﺮ ‪ ،Test‬ﻣﻘﺪار ٢ را ﺧﻮاهـﺪ داﺷـﺖ و ﺑﻘﻴـﻪ ﺷـﺮوط ﺑـﻪ هﻤـﻴﻦ‬ ‫ﺗﺮﺗﻴﺐ.‬ ‫ﺗﻮﺟﻪ: اﮔﺮ ‪ X‬و ‪ ،Y‬ﺻـﻔﺮ ﺑﺎﺷـﻨﺪ، هﻴﭽﻜـﺪام از ﻋﺒـﺎرات ﺻـﺤﻴﺢ ﻧﺨﻮاهﻨـﺪ ﺑـﻮد و ﻣﻘـﺪار ‪Null ،Test‬‬ ‫ﺧﻮاهﺪ ﺷﺪ.‬ ‫)‪Environ(expression‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺟﻬﺖ ﺑﺮﮔﺸﺖ ﻣﺘﻐﻴﺮهﺎي ﻣﺤﻠﻲ ﺑﻪ آﺎر ﻣﻲ رود.‬ ‫ﻣﺘﻐﻴﺮهﺎي ﻣﺤﻠﻲ، ﻣﺘﻐﻴﺮهﺎي ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ هﺴﺘﻨﺪ آـﻪ ﺑـﺎ ﻓﺮﻣـﺎن ‪ SET‬در ﺁن ﻗـﺮار دادﻩ ﺷـﺪﻩ‬ ‫اﻧﺪ.‬ ‫ﺑﺮاي دﺳﺘﺮﺳﻲ ﺑﻪ ﻣﺤﺘﻮﻳﺎت ﻳـﻚ ﻣﺘﻐﻴـﺮ ﻣﺤﻠـﻲ در ﺳﻴـﺴﺘﻢ، از ﻳـﻚ ﻋـﺪد ﻳـﺎ ﻧـﺎم ﺁن در ﺁرﮔﻮﻣـﺎن‬ ‫‪ expression‬اﺳﺘﻔﺎدﻩ آﻨﻴﺪ.‬ ‫دﺳﺘﻮ زﻳﺮ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ:‬ ‫))2(‪Console.WriteLine(Environ‬‬ ‫ﺑﻪ آﻤﻚ دﺳﺘﻮر ﻓﻮق، هﻢ، ﻧﺎم ﻣﺘﻐﻴﺮ ﻣﺤﻠﻲ و هﻢ ﻣﻘﺪار ﺁن در ﺧﺮوﺟﻲ ﻧﻤﺎﻳﺶ دادﻩ ﻣﻲ ﺷﻮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل:‬ ‫‪TMP=C:WINDOWS TEMP‬‬ ‫ﺑﺮاي ﺑﻪ دﺳﺖ ﺁوردن ﺗﻨﻬﺎ، ﻣﻘـﺪار ﻣﺘﻐﻴـﺮ ﻣﺤﻠـﻲ ‪ ،TMP‬ﺑﺎﻳـﺪ ﻧـﺎم ﺁن را در ﺁرﮔﻮﻣـﺎن ‪expression‬‬ ‫ذآﺮ آﻨﻴﺪ هﻤﺎﻧﻨﺪ زﻳﺮ:‬ ‫))” ‪Console.WriteLine(Environ(“TMP‬‬ ‫دﺳﺘﻮر ﻓﻮق، ﻋﺒﺎرت زﻳﺮ را ﻧﻤﺎﻳﺶ ﺧﻮاهﺪ داد:‬ ‫‪C:WINDOWS TEMP‬‬ ‫ﻣﺜﻼ دﺳﺘﻮر زﻳﺮ، ﻣﺴﻴﺮ ﭘﻮﺷﻪ وﻳﻨﺪوز ﺷﻤﺎ را ﻧﻤﺎﻳﺶ ﻣﻲ دهﺪ:‬ ‫)”‪Console.WriteLine(Environ(“WinDir‬‬ ‫ﺑﺎ اﺳﺘﻔﺎدﻩ از دﺳﺘﻮر ﻓﻮق ﻧﻴـﺎزي ﺑـﻪ اﺳـﺘﻔﺎدﻩ از ﺗـﺎﺑﻊ ‪ API‬ﺑـﺮاي ﺑـﻪ دﺳـﺖ ﺁوردن ﻣـﺴﻴﺮ ﻧـﺼﺐ‬ ‫وﻳﻨﺪوز ﻧﺪارﻳﺪ.‬ ‫ﺑﺮاي ﺑﻪ دﺳﺖ ﺁوردن ﻣﻘﺎدﻳﺮ ﻣﺘﻐﻴﺮهﺎي ﻣﺤﻠﻲ ﻣﻮﺟﻮد در ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﺧﻮد، ﺑـﻪ ﺗﺮﺗﻴـﺐ از ﻋـﺪد‬ ‫١ ﺷﺮوع آﺮدﻩ و اﻳﻦ اﻋﺪاد را در ﺁرﮔﻮﻣـﺎن ‪ expression‬ﻗـﺮار دهﻴـﺪ ﺗـﺎ زﻣـﺎﻧﻲ آـﻪ اﻳـﻦ ﺗـﺎﺑﻊ، ﻳـﻚ‬ ‫ﻣﻘﺪار ﺧﺎﻟﻲ را ﺑﺮﮔﺸﺖ دهﺪ.‬ ‫ﻧﻜﺘﻪ: در ﺻﻮرﺗﻲ آﻪ ﻋﺪد ﻳﺎ ﻧﺎم ﻣﺘﻐﻴﺮ ﻣﺤﻠﻲ آﻪ ذآﺮ ﻣﻲ آﻨﻴﺪ وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ، اي ﺗـﺎﺑﻊ ﻳـﻚ‬ ‫ﻣﻘﺪار ﺧﺎﻟﻲ را ﺑﺮﮔﺸﺖ ﻣﻲ دهﺪ.‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٣٦‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 64.
    ‫‪Beep‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺟﻬﺖ اﻳﺠﺎد ﻳﻚ ﺻﺪاي ﺑﻴﭗ آﻮﺗﺎﻩ ﺑﻪ آﺎر ﻣﻲ رود.‬ ‫ﻃﻮل زﻣﺎن ﭘﺨﺶ اﻳﻦ ﺻﺪاي ﺑﻴﭗ، ﻗﺎﺑﻞ ﺗﻨﻈﻴﻢ ﻧﻴﺴﺖ.‬ ‫اﺳﺘﻔﺎدﻩ از اﻳﻦ ﺗﺎﺑﻊ ﻧﻴﺎزي ﺑﻪ ﻧﺼﺐ ﺑﻮدن ﻳﺎ داﺷﺘﻦ آﺎرت ﺻﺪا ﻧﺪارد.‬ ‫)])(‪CallByName(object,procedurename,calltype [,arguments‬‬ ‫اﻳﻦ ﺗﺎﺑﻊ ﺟﻬﺖ اﺟﺮاي ﻳﻜﻲ از ﻣﺘﺪهﺎي ﻳﻚ ﺷﻲ ﻳﺎ ﺗﻌﻴﻴﻦ ﻣﻘﺪار ﺧﻮاص ﺷﻲ ﻳـﺎ ﺑﺮﮔﺮداﻧـﺪن ﻣﻘـﺪار‬ ‫ﻳﻜﻲ از ﺧﻮاص ﺷﻲ ﺑﻪ آﺎر ﻣﻲ رود.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،object‬ﻧﺎم ﺷﻲ ﻣﻮرد ﻧﻈﺮ اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،procedurename‬ﻧﺎم ﻳﻚ ﺧﻮاص ﻳﺎ ﻣﺘﺪ ﺷﻲ اﺳﺖ.‬ ‫ﺁرﮔﻮﻣﺎن ‪ ،calltype‬ﻧﻮع ﻋﻤﻠـﻲ آـﻪ ﻣـﻲ ﺧـﻮاهﻴﻢ اﻧﺠـﺎم ﺷـﻮد را ﻣـﺸﺨﺺ ﻣـﻲ آﻨـﺪ و ﻳﻜـﻲ از‬ ‫ﻣﻘﺎدﻳﺮ زﻳﺮ را ﻣﻲ ﭘﺬﻳﺮد:‬ ‫ﭘﺎراﻣﺘﺮ ‪ calltype‬در ﺗﺎﺑﻊ )(‪CallByName‬‬ ‫ﻣﻘﺎدﻳﺮ‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻣﻘﺪار‬ ‫ﻣﻘﺪار ﻳﻚ ﺧﺎﺻﻴﺖ ﺷﻲ را ﻣﻲ ﺧﻮاﻧﺪ‬ ‫‪Get‬‬ ‫ﻣﻘﺪار ﻳﻚ ﺧﺎﺻﻴﺖ ﺷﻲ را ﺗﻌﻴﻴﻦ ﻣﻲ آﻨﺪ‬ ‫‪Set‬‬ ‫ﻳﻚ ﻣﺘﺪ از ﺷﻲ را ﻓﺮاﺧﻮاﻧﻲ و اﺟﺮا ﻣﻲ آﻨﺪ‬ ‫‪Method‬‬ ‫ﺁﺧﺮﻳﻦ ﺁرﮔﻮﻣﺎن اﻳﻦ ﺗﺎﺑﻊ آﻪ ‪ arguments‬ﻧﺎم دارد، ﻳﻚ ﺁراﻳﻪ از ﻣﻘﺎدﻳﺮ اﺳﺖ.‬ ‫اﮔﺮ از ﻣﻘﺪار ‪ Set‬اﺳﺘﻔﺎدﻩ آﻨﻴﻢ، ﺑﺎﻳﺪ ﻣﻘﺪاري را آﻪ ﻣﻲ ﺧﻮاهﻴﻢ ﺑﻪ ﻳﻜﻲ از ﺧﺎﺻﻴﺖ هـﺎي ﺷـﻲ‬ ‫ﻧﺴﺒﺖ دهﻴﻢ در اﻳﻦ ﺁرﮔﻮﻣﺎن ذآﺮ آﻨﻴﻢ.‬ ‫اﮔﺮ از ﻣﻘﺪار ‪ Method‬اﺳﺘﻔﺎدﻩ ﻣﻲ آﻨﻴﻢ، ﻣﻤﻜﻦ اﺳﺖ ﻣﺘﺪ ﺗﺎﺑﻊ ﻣﺎ ﺑﺮاي اﻧﺠﺎم آﺎر ﺧـﻮد ﻧﻴـﺎز ﺑـﻪ‬ ‫ﭘﺎراﻣﺘﺮهﺎ ﻳﺎ ﻣﻘﺎدﻳﺮي داﺷﺘﻪ ﺑﺎﺷﺪ، ﭘﺲ ﺁﻧﻬﺎ را ﺑﻪ ﺗﺮﺗﻴﺐ در اﻳﻦ ﺁرﮔﻮﻣﺎن ﻳﻌﻨﻲ ‪ arguments‬ذآﺮ‬ ‫ﻣﻲ آﻨﻴﻢ.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺑﻪ ﻃﻮر ﻣﻌﻤﻮل ﺑﺮاي ﺁﻧﻜﻪ ﺑﻪ ﺧﺎﺻﻴﺖ ‪ Text‬از ﺷﻲ ‪ ،TextBox‬ﻣﻘﺪاري را ﻧﺴﺒﺖ‬ ‫دهﻴﻢ، ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ ﻣﻲ آﻨﻴﻢ:‬ ‫"‪TextBox1.Text = “Welcome To VB.NET‬‬ ‫ﺣﺎﻻ هﻤﻴﻦ آﺎر را ﺑﺎ اﺳﺘﻔﺎدﻩ از ﺗﺎﺑﻊ )(‪ CallByName‬اﻧﺠﺎم ﻣﻲ دهﻴﻢ:‬ ‫)” ‪CallByName(TextBox1, “Text ”, CallType.Set, “Welcome to VB.NET‬‬ ‫ﺗﻮﺟﻪ: اوﻟﻴﻦ ﺁرﮔﻮﻣﺎن آﻪ ﺑﺎﻳﺪ ﻧﺎم ﺷﻲ ﻣﻮرد ﻧﻈـﺮ در ﺁن ذآـﺮ ﺷـﻮد، ﻳـﻚ ﻣﻘـﺪار رﺷـﺘﻪ اي ﻧﻴـﺴﺖ‬ ‫ﺑﻠﻜﻪ ﻧﺎم اﺻﻠﻲ ﺷﻲ را ﺑﺪون هﻴﭻ آﺎراآﺘﺮ اﺿﺎﻓﻲ ﺑﺎﻳﺪ ذآﺮ آﺮد.‬ ‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل، دﺳﺘﻮر زﻳﺮ اﺷﺘﺒﺎﻩ اﺳﺖ و ﻳﻚ ﺧﻄﺎي زﻣﺎن اﺟﺮا اﺗﻔﺎق ﺧﻮاهﺪ اﻓﺘﺎد:‬ ‫”1‪ObjectName =“TextBox‬‬ ‫”‪CallByName ObjectName, “Text”, CallType.Set, “Welcome to VB.NET‬‬ ‫در ﺻﻮرﺗﻲ آﻪ ﻣﻲ ﺧﻮاهﻴﺪ ﻧﺎم ﺷـﻲ را در ﻳـﻚ ﻣﺘﻐﻴـﺮ ﻗـﺮار دهﻴـﺪ ﺑﺎﻳـﺪ اﺑﺘـﺪا ﺁن را از ﻧـﻮع ‪Object‬‬ ‫ﺗﻌﺮﻳﻒ آﻨﻴﺪ. ﭘﺲ دﺳﺘﻮر ﻓﻮق را ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺻﻼح ﻣﻲ آﻨﻴﻢ:‬ ‫‪Dim MyObject As Object‬‬ ‫1‪MyObject =TextBox‬‬ ‫”‪CallByName MyObject, “Text”, CallType.Set, “Welcome to VB.NET‬‬ ‫ﺑﺮاي ﺑﻪ دﺳﺖ ﺁوردن ﻣﻘﺪار ﺧﺎﺻﻴﺖ ‪ Text‬از ﺷﻲ ‪ TextBox‬ﻧﻴﺰ ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻋﻤﻞ آﻨﻴﺪ:‬ ‫)‪MyText = CallByName(TextBox1, “Text”, CallType.Get‬‬ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ‫٤٦‬ ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ ‪Visual Basic.NET‬‬
  • 65.
    ‫ﺗﺎرﻳﺨﭽﻪ وﻳﮋوال ﺑﻴﺴﻴﻚ‬ Visual Basic 1.0 ١٩٩١ ‫٠٢ ﻣﻲ‬ Visual Basic 2.0 ١٩٩٢ ‫ﻣﺎرس‬ Visual Basci 3.0 ١٩٩٣ ‫ژوﺋﻦ‬ Visual Basci 4.0 ١٩٩٦ ‫اآﺘﺒﺮ‬ Visual Basci 5.0 ١٩٩٧ ‫ﺁورﻳﻞ‬ Visual Basic 6.0 ١٩٩٨ ‫٦١ ژوﺋﻦ‬ Visual Basic .NET ٢٠٠١ ‫ﺑﻪ وﺳﻴﻠﻪ: ﺑﻬﺮوز راد‬ ٦٥ Visual Basic.NET ‫ﺁﻣﻮزش آﺎرﺑﺮدي ﺗﻮاﺑﻊ‬