‫ﺑﺴﻢ اﷲ اﻟﺮﺣﻤﻦ اﻟﺮﺣﻴﻢ‬

‫‪ ‬‬

‫‪Socket Programming‬‬
‫ﺑﻪ ﻛﻤﻚ ‪C#‬‬

‫ﮔﺮدآورﻧﺪه‪ :‬ﺑﺎﺑﻚ ﻟﻮﻧﻲ‬

‫داﻧﺸﻜﺪه رﻳﺎﺿﻲ و ﻋﻠﻮم ﻛﺎﻣﭙﻴﻮﺗﺮ داﻧﺸﮕﺎه ﺻﻨﻌﺘﻲ اﻣﻴﺮﻛﺒﻴﺮ‬
‫دي ﻣﺎه ‪1386‬‬

‫ﭼﻜﻴﺪه‬
‫در اﻳﻦ ﻣﺴﺘﻨﺪ ﺑﻪ ﺷﺮح ﭼﮕﻮﻧﮕﻲ ﻃﺮاﺣﻲ و ﭘﻴﺎده ﺳﺎزي ﻳﻚ ﻧﺮم اﻓﺰار ﺳﺎده ﺑﻪ ﻛﻤﻚ ‪  ‬ﺗﻜﻨﻴﻚ ﻫﺎي ﺑﺮﻧﺎﻣﻪ‬
‫ﻧﻮﻳﺴﻲ ﺳﻮﻛﺖ در زﺑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ‪ C#‬ﭘﺮداﺧﺘﻪ اﻳﻢ‪ .‬ﻣﻬﻢ ﺗﺮﻳﻦ ﻣﻔﺎﻫﻴﻤﻲ ﻛﻪ از آﻧﻬﺎ ﺑﺮاي ﭘﻴﺎده ﺳﺎزي‬
‫ﭘﺮوژه ﻣﻮرد اﺳﺘﻔﺎده ﻗﺮار ﮔﺮﻓﺘﻪ اﺳﺖ ﭘﺮوﺗﻜﻞ ‪ TCP/IP‬و ﻣﻔﺎﻫﻴﻢ ﺳﻮﻛﺖ ﺑﻮده ﻛﻪ در اﻳﻦ ﻣﺴﺘﻨﺪ اﺑﺘﺪاﻋﺎٌ‬
‫ﻣﺮوري ﺑﺮ اﻳﻦ ﻣﻔﺎﻫﻴﻢ داﺷﺘﻪ اﻳﻢ ﺳﭙﺲ از اﻳﻦ ﻣﻔﺎﻫﻴﻢ ﺑﺮاي ﭘﻴﺎده ﺳﺎزي ﻳﻚ ﻛﺪ ﺳﺎده ﺑﻬﺮه ﺟﺴﺘﻪ اﻳﻢ‪  .‬‬
‫در اداﻣﻪ ﻣﻘﺪﻣﻪ اي ﺑﺮ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺷﺒﻜﻪ ﺑﻪ ﺧﺼﻮص در ‪ C#‬و ﺗﻜﻨﻮﻟﻮژي ‪ .NET‬داﺷﺘﻪ اﻳﻢ ﺳﭙﺲ ﻗﺴﻤﺖ‬
‫ﻫﺎي اﺻﻠﻲ ﭘﻴﺎده ﺳﺎزي را ﺑﻪ ﻫﻤﺮاه ﻛﺪ ﺑﻪ ﻛﺎر رﻓﺘﻪ در آﻧﻬﺎ ﺷﺮح داده اﻳﻢ‪.‬‬

‫ﻓﻬﺮﺳﺖ‬
‫‪ ‬‬
‫ﭼﻜﻴﺪه‪  2 ...................................................................................................................................................‬‬
‫ﻓﻬﺮﺳﺖ‪  3 ................................................................................................................................................. ‬‬
‫ﻣﻔﺎﻫﻴﻢ اوﻟﻴﻪ ﭘﺮوﺗﻜﻞ‪  3 .........................................................................................................................  TCP/IP‬‬
‫ﻣﻌﺮﻓﻲ ﭘﺮوﺗﻜﻞ ‪  4 ........................................................................................................................... TCP/IP‬‬
‫ﻻﻳﻪ ﻫﺎي ﭘﺮوﺗﻜﻞ ‪  5 ........................................................................................................................ TCP/IP‬‬
‫ﻣﺸﺨﺺ ﻧﻤﻮدن ﺑﺮﻧﺎﻣﻪ ﻫﺎ‪  5 .......................................................................................................................... ‬‬
‫آدرس ‪  6 ............................................................................................................................................ IP‬‬
‫ﭘﻮرت ‪  6 .................................................................................................................................. TCP/UDP‬‬
‫ﺳﻮﻛﺖ )‪  6 .................................................................................................................................. (Socket‬‬
‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺷﺒﻜﻪ‪  6 .................................................................................................................................... ‬‬
‫ﻣﺮاﺣﻞ ﭘﻴﺎده ﺳﺎزي ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺳﻮﻛﺖ در ‪  8 ...................................................................................................... C#‬‬
‫ﻃﺮﻳﻘﻪ اﺗﺼﺎل‪  8 ........................................................................................................................................ ‬‬
‫ﭘﻴﺎده ﺳﺎزي اﺻﻮل اوﻟﻴﻪ‪  8 ............................................................................................................................. ‬‬
‫ﭘﻴﺎده ﺳﺎزي ﺑﺎ ﺳﻮﻛﺖ ﻫﺎي ﺳﻨﻜﺮون‪  9 ............................................................................................................ ‬‬
‫ﭘﻴﺎده ﺳﺎزي ﺑﺎ ﺳﻮﻛﺖ ﻫﺎي آﺳﻨﻜﺮون‪  12 ......................................................................................................... ‬‬
‫ﻳﻚ ﻣﺜﺎل ﺳﺎده‪  17 .................................................................................................................................... ‬‬
‫ﺿﻤﻴﻤﻪ‪ :‬ﻣﻌﺮﻓﻲ ﻣﺨﺘﺼﺮ ﻓﻀﺎﻫﺎي ﻧﺎﻣﻲ اﺳﺘﻔﺎده ﺷﺪه‪  20 ................................................................................................ ‬‬
‫‪  20 ................................................................................................................................... System.Net‬‬
‫‪  20 ..................................................................................................................................... System.IO‬‬
‫‪  20 ........................................................................................................................ ،System.Threading‬‬

‫ﻣﻔﺎﻫﻴﻢ اوﻟﻴﻪ ﭘﺮوﺗﻜﻞ‪TCP/IP‬‬
‫‪ ، TCP/IP‬ﻳﻜﻲ از ﻣﻬﻤﺘﺮﻳﻦ ﭘﺮوﺗﻜﻞ ﻫﺎي اﺳﺘﻔﺎده ﺷﺪه در ﺷﺒﻜﻪ ﻫﺎي ﻛﺎﻣﭙﻴﻮﺗﺮي اﺳﺖ ‪ .‬اﻳﻨﺘﺮﻧﺖ ﺑﻌﻨﻮان‬
‫ﺑﺰرﮔﺘﺮﻳﻦ ﺷﺒﻜﻪ ﻣﻮﺟﻮد ‪ ،‬از ﭘﺮوﺗﻜﻞ ﻓﻮق ﺑﻤﻨﻈﻮر ارﺗﺒﺎط دﺳﺘﮕﺎه ﻫﺎي ﻣﺘﻔﺎوت اﺳﺘﻔﺎده ﻣﻲ ﻧﻤﺎﻳﺪ‪ .‬ﭘﺮوﺗﻜﻞ ‪،‬‬
‫ﻣﺠﻤﻮﻋﻪ ﻗﻮاﻧﻴﻦ ﻻزم ﺑﻤﻨﻈﻮر ﻗﺎﻧﻮﻧﻤﻨﺪ ﻧﻤﻮدن ﻧﺤﻮه ارﺗﺒﺎﻃﺎت در ﺷﺒﻜﻪ ﻫﺎي ﻛﺎﻣﭙﻴﻮﺗﺮي اﺳﺖ‪ .‬در اﻳﻦ ﺑﺨﺶ‬
‫ﻣﻮاردي ﻫﻤﭽﻮن ‪ :‬ﻓﺮآﻳﻨﺪ اﻧﺘﻘﺎل اﻃﻼﻋﺎت ‪ ،‬ﻣﻌﺮﻓﻲ و ﺗﺸﺮﻳﺢ ﻻﻳﻪ ﻫﺎي ﭘﺮوﺗﻜﻞ ‪ TCP/IP‬و ﻧﺤﻮه اﺳﺘﻔﺎده از‬
‫ﺳﻮﻛﺖ ﺑﺮاي اﻳﺠﺎد ﺗﻤﺎﻳﺰ در ارﺗﺒﺎﻃﺎت ‪ ،‬ﺗﺸﺮﻳﺢ ﻣﻲ ﮔﺮدد‪.‬‬
‫اﻣﺮوزه اﻛﺜﺮ ﺷﺒﻜﻪ ﻫﺎي ﻛﺎﻣﭙﻴﻮﺗﺮي ﺑﺰرگ و اﻏﻠﺐ ﺳﻴﺴﺘﻢ ﻫﺎي ﻋﺎﻣﻞ ﻣﻮﺟﻮد از ﭘﺮوﺗﻜﻞ ‪ ، TCP/IP‬اﺳﺘﻔﺎده و‬
‫ﺣﻤﺎﻳﺖ ﻣﻲ ﻧﻤﺎﻳﻨﺪ‪ ، TCP/IP .‬اﻣﻜﺎﻧﺎت ﻻزم ﺑﻤﻨﻈﻮر ارﺗﺒﺎط ﺳﻴﺴﺘﻢ ﻫﺎي ﻏﻴﺮﻣﺸﺎﺑﻪ را ﻓﺮاﻫﻢ ﻣﻲ آورد‪ .‬از‬
‫وﻳﮋﮔﻲ ﻫﺎي ﻣﻬﻢ ﭘﺮوﺗﻜﻞ ﻓﻮق ‪ ،‬ﻣﻲ ﺗﻮان ﺑﻪ ﻣﻮاردي ﻫﻤﭽﻮن ‪ :‬ﻗﺎﺑﻠﻴﺖ اﺟﺮاء ﺑﺮ روي ﻣﺤﻴﻂ ﻫﺎي ﻣﺘﻔﺎوت ‪،‬‬
‫ﺿﺮﻳﺐ اﻃﻤﻴﻨﺎن ﺑﺎﻻ‪ ،‬ﻗﺎﺑﻠﻴﺖ ﮔﺴﺘﺮش و ﺗﻮﺳﻌﻪ آن ‪ ،‬اﺷﺎره ﻛﺮد ‪ .‬از ﭘﺮوﺗﻜﻞ ﻓﻮق‪ ،‬ﺑﻤﻨﻈﻮر دﺳﺘﻴﺎﺑﻲ ﺑﻪ اﻳﻨﺘﺮﻧﺖ‬
‫و اﺳﺘﻔﺎده از ﺳﺮوﻳﺲ ﻫﺎي ﻣﺘﻨﻮع آن ﻧﻈﻴﺮ وب و ﻳﺎ ﭘﺴﺖ اﻟﻜﺘﺮوﻧﻴﻜﻲ اﺳﺘﻔﺎده ﻣﻲ ﮔﺮدد‪ .‬ﺗﻨﻮع ﭘﺮوﺗﻜﻞ ﻫﺎي‬
‫ﻣﻮﺟﻮد در ﭘﺸﺘﻪ ‪ TCP/IP‬و ارﺗﺒﺎط ﻣﻨﻄﻘﻲ و ﺳﻴﺴﺘﻤﺎﺗﻴﻚ آﻧﻬﺎ ﺑﺎ ﻳﻜﺪﻳﮕﺮ‪ ،‬اﻣﻜﺎن ﺗﺤﻘﻖ ارﺗﺒﺎط در ﺷﺒﻜﻪ ﻫﺎي‬
‫ﻛﺎﻣﭙﻴﻮﺗﺮي را ﺑﺎ اﻫﺪاف ﻣﺘﻔﺎوت ‪ ،‬ﻓﺮاﻫﻢ ﻣﻲ ﻧﻤﺎﻳﺪ‪ .‬ﻓﺮآﻳﻨﺪ ﺑﺮﻗﺮاري ﻳﻚ ارﺗﺒﺎط ‪ ،‬ﺷﺎﻣﻞ ﻓﻌﺎﻟﻴﺖ ﻫﺎي ﻣﺘﻌﺪدي‬
‫ﻧﻈﻴﺮ ‪ :‬ﺗﺒﺪﻳﻞ ﻧﺎم ﻛﺎﻣﭙﻴﻮﺗﺮ ﺑﻪ آدرس ‪ IP‬ﻣﻌﺎدل ‪ ،‬ﻣﺸﺨﺺ ﻧﻤﻮدن ﻣﻮﻗﻌﻴﺖ ﻛﺎﻣﭙﻴﻮﺗﺮ ﻣﻘﺼﺪ ‪ ،‬ﺑﺴﺘﻪ ﺑﻨﺪي‬
‫اﻃﻼﻋﺎت ‪ ،‬آدرس دﻫﻲ و روﺗﻴﻨﮓ داده ﻫﺎ ﺑﻤﻨﻈﻮر ارﺳﺎل ﻣﻮﻓﻘﻴﺖ آﻣﻴﺰ ﺑﻪ ﻣﻘﺼﺪ ﻣﻮرد ﻧﻈﺮ ‪ ،‬ﺑﻮده ﻛﻪ ﺗﻮﺳﻂ‬
‫ﻣﺠﻤﻮﻋﻪ ﭘﺮوﺗﻜﻞ ﻫﺎي ﻣﻮﺟﻮد در ﭘﺸﺘﻪ ‪ TCP/IP‬اﻧﺠﺎم ﻣﻲ ﮔﻴﺮد‪.‬‬

‫ﻣﻌﺮﻓﻲ ﭘﺮوﺗﻜﻞ ‪TCP/IP‬‬
‫‪ ، TCP/IP‬ﭘﺮوﺗﻜﻠﻲ اﺳﺘﺎﻧﺪارد ﺑﺮاي ارﺗﺒﺎط ﻛﺎﻣﭙﻴﻮﺗﺮﻫﺎي ﻣﻮﺟﻮد در ﻳﻚ ﺷﺒﻜﻪ ﻣﺒﺘﻨﻲ ﺑﺮ وﻳﻨﺪوز ‪ 2000‬اﺳﺖ‪ .‬از‬
‫ﭘﺮوﺗﻜﻞ ﻓﻮق‪ ،‬ﺑﻤﻨﻈﻮر ارﺗﺒﺎط در ﺷﺒﻜﻪ ﻫﺎي ﺑﺰرگ اﺳﺘﻔﺎده ﻣﻲ ﮔﺮدد‪ .‬ﺑﺮﻗﺮاري ارﺗﺒﺎط از ﻃﺮﻳﻖ ﭘﺮوﺗﻜﻞ ﻫﺎي‬
‫ﻣﺘﻌﺪدي ﻛﻪ در ﭼﻬﺎرﻻﻳﻪ ﻣﺠﺰا ﺳﺎزﻣﺎﻧﺪﻫﻲ ﺷﺪه اﻧﺪ ‪ ،‬ﻣﻴﺴﺮ ﻣﻲ ﮔﺮدد‪ .‬ﻫﺮ ﻳﻚ از ﭘﺮوﺗﻜﻞ ﻫﺎي ﻣﻮﺟﻮد در‬
‫ﭘﺸﺘﻪ ‪ ، TCP/IP‬داراي وﻇﻴﻔﻪ اي ﺧﺎص در اﻳﻦ زﻣﻴﻨﻪ ) ﺑﺮﻗﺮاري ارﺗﺒﺎط( ﻣﻲ ﺑﺎﺷﻨﺪ ‪ .‬در زﻣﺎن اﻳﺠﺎد ﻳﻚ‬
‫ارﺗﺒﺎط ‪ ،‬ﻣﻤﻜﻦ اﺳﺖ در ﻳﻚ ﻟﺤﻈﻪ ﺗﻌﺪاد زﻳﺎدي از ﺑﺮﻧﺎﻣﻪ ﻫﺎ ‪ ،‬ﺑﺎ ﻳﻜﺪﻳﮕﺮ ارﺗﺒﺎط ﺑﺮﻗﺮار ﻧﻤﺎﻳﻨﺪ‪، TCP/IP .‬‬
‫داراي ﻗﺎﺑﻠﻴﺖ ﺗﻔﻜﻴﻚ و ﺗﻤﺎﻳﺰ ﻳﻚ ﺑﺮﻧﺎﻣﻪ ﻣﻮﺟﻮد ﺑﺮ روي ﻳﻚ ﻛﺎﻣﭙﻴﻮﺗﺮ ﺑﺎ ﺳﺎﻳﺮ ﺑﺮﻧﺎﻣﻪ ﻫﺎ ﺑﻮده و ﭘﺲ از درﻳﺎﻓﺖ‬

‫داده ﻫﺎ از ﻳﻚ ﺑﺮﻧﺎﻣﻪ ‪ ،‬آﻧﻬﺎ را ﺑﺮاي ﺑﺮﻧﺎﻣﻪ ﻣﺘﻨﺎﻇﺮ ﻣﻮﺟﻮد ﺑﺮ روي ﻛﺎﻣﭙﻴﻮﺗﺮ دﻳﮕﺮ ارﺳﺎل ﻣﻲ ﻧﻤﺎﻳﺪ‪ .‬ﻧﺤﻮه‬
‫ارﺳﺎل داده ﺗﻮﺳﻂ ﭘﺮوﺗﻜﻞ ‪ TCP/IP‬از ﻣﺤﻠﻲ ﺑﻪ ﻣﺤﻞ دﻳﮕﺮ ‪ ،‬ﺑﺎ ﻓﺮآﻳﻨﺪ ارﺳﺎل ﻳﻚ ﻧﺎﻣﻪ از ﺷﻬﺮي ﺑﻪ ﺷﻬﺮ‪،‬‬
‫ﻗﺎﺑﻞ ﻣﻘﺎﻳﺴﻪ اﺳﺖ ‪.‬‬
‫ﺑﺮﻗﺮاري ارﺗﺒﺎط ﻣﺒﺘﻨﻲ ﺑﺮ ‪ ، TCP/IP‬ﺑﺎ ﻓﻌﺎل ﺷﺪن ﻳﻚ ﺑﺮﻧﺎﻣﻪ ﺑﺮ روي ﻛﺎﻣﭙﻴﻮﺗﺮ ﻣﺒﺪا آﻏﺎز ﻣﻲ ﮔﺮدد ‪ .‬ﺑﺮﻧﺎﻣﻪ‬
‫ﻓﻮق ‪،‬داده ﻫﺎي ﻣﻮرد ﻧﻈﺮ ﺟﻬﺖ ارﺳﺎل را ﺑﮕﻮﻧﻪ اي آﻣﺎده و ﻓﺮﻣﺖ ﻣﻲ ﻧﻤﺎﻳﺪ ﻛﻪ ﺑﺮاي ﻛﺎﻣﭙﻴﻮﺗﺮ ﻣﻘﺼﺪ ﻗﺎﺑﻞ‬
‫ﺧﻮاﻧﺪن و اﺳﺘﻔﺎده ﺑﺎﺷﻨﺪ‪ ) .‬ﻣﺸﺎﺑﻪ ﻧﻮﺷﺘﻦ ﻧﺎﻣﻪ ﺑﺎ زﺑﺎﻧﻲ ﻛﻪ درﻳﺎﻓﺖ ﻛﻨﻨﺪه ‪ ،‬ﻗﺎدر ﺑﻪ ﻣﻄﺎﻟﻌﻪ آن ﺑﺎﺷﺪ( ‪ .‬در اداﻣﻪ‬
‫آدرس ﻛﺎﻣﭙﻴﻮﺗﺮ ﻣﻘﺼﺪ ‪ ،‬ﺑﻪ داده ﻫﺎي ﻣﺮﺑﻮﻃﻪ اﺿﺎﻓﻪ ﻣﻲ ﮔﺮدد ) ﻣﺸﺎﺑﻪ آدرس ﮔﻴﺮﻧﺪه ﻛﻪ ﺑﺮ روي ﻳﻚ ﻧﺎﻣﻪ‬
‫ﻣﺸﺨﺺ ﻣﻲ ﮔﺮدد( ‪ .‬ﭘﺲ از اﻧﺠﺎم ﻋﻤﻠﻴﺎت ﻓﻮق ‪ ،‬داده ﺑﻪ ﻫﻤﺮاه اﻃﻼﻋﺎت اﺿﺎﻓﻲ ) درﺧﻮاﺳﺘﻲ ﺑﺮاي ﺗﺎﺋﻴﺪ‬
‫درﻳﺎﻓﺖ در ﻣﻘﺼﺪ ( ‪ ،‬در ﻃﻮل ﺷﺒﻜﻪ ﺑﻪ ﺣﺮﻛﺖ درآﻣﺪه ﺗﺎ ﺑﻪ ﻣﻘﺼﺪ ﻣﻮرد ﻧﻈﺮ ﺑﺮﺳﺪ‪ .‬ﻋﻤﻠﻴﺎت ﻓﻮق ‪ ،‬ارﺗﺒﺎﻃﻲ‬
‫ﺑﻪ ﻣﺤﻴﻂ اﻧﺘﻘﺎل ﺷﺒﻜﻪ ﺑﻪ ﻣﻨﻈﻮر اﻧﺘﻘﺎل اﻃﻼﻋﺎت ﻧﺪاﺷﺘﻪ ‪ ،‬و ﺗﺤﻘﻖ ﻋﻤﻠﻴﺎت ﻓﻮق ﺑﺎ روﻳﻜﺮدي ﻣﺴﺘﻘﻞ ﻧﺴﺒﺖ‬
‫ﺑﻪ ﻣﺤﻴﻂ اﻧﺘﻘﺎل ‪ ،‬اﻧﺠﺎم ﺧﻮاﻫﺪ ﺷﺪ ‪.‬‬

‫ﻻﻳﻪ ﻫﺎي ﭘﺮوﺗﻜﻞ ‪TCP/IP‬‬
‫‪ ، TCP/IP‬ﻓﺮآﻳﻨﺪﻫﺎي ﻻزم ﺑﻤﻨﻈﻮر ﺑﺮﻗﺮاري ارﺗﺒﺎط را ﺳﺎزﻣﺎﻧﺪﻫﻲ و در اﻳﻦ راﺳﺘﺎ از ﭘﺮوﺗﻜﻞ ﻫﺎي ﻣﺘﻌﺪدي در‬
‫ﭘﺸﺘﻪ ‪ TCP/IP‬اﺳﺘﻔﺎده ﻣﻲ ﮔﺮدد‪ .‬ﺑﻤﻨﻈﻮر اﻓﺰاﻳﺶ ﻛﺎرآﺋﻲ در ﺗﺤﻘﻖ ﻓﺮآﻳﻨﺪ ﻫﺎي ﻣﻮرد ﻧﻈﺮ‪ ،‬ﭘﺮوﺗﻜﻞ ﻫﺎ در ﻻﻳﻪ‬
‫ﻫﺎي ﻣﺘﻔﺎوﺗﻲ‪ ،‬ﺳﺎزﻣﺎﻧﺪﻫﻲ ﺷﺪه اﻧﺪ ‪ .‬اﻃﻼﻋﺎت ﻣﺮﺑﻮط ﺑﻪ آدرس دﻫﻲ در اﻧﺘﻬﺎ ﻗﺮار ﮔﺮﻓﺘﻪ و ﺑﺪﻳﻦ ﺗﺮﺗﻴﺐ‬
‫ﻛﺎﻣﭙﻴﻮﺗﺮﻫﺎي ﻣﻮﺟﻮد در ﺷﺒﻜﻪ ﻗﺎدر ﺑﻪ ﺑﺮرﺳﻲ آن ﺑﺎ ﺳﺮﻋﺖ ﻣﻄﻠﻮب ﺧﻮاﻫﻨﺪ ﺑﻮد‪ .‬در اﻳﻦ راﺳﺘﺎ‪ ،‬ﺻﺮﻓﺎ‬
‫ﻛﺎﻣﭙﻴﻮﺗﺮي ﻛﻪ ﺑﻌﻨﻮان ﻛﺎﻣﭙﻴﻮﺗﺮ ﻣﻘﺼﺪ ﻣﻌﺮﻓﻲ ﺷﺪه اﺳﺖ ‪ ،‬اﻣﻜﺎن ﺑﺎز ﻧﻤﻮدن ﺑﺴﺘﻪ اﻃﻼﻋﺎﺗﻲ و اﻧﺠﺎم ﭘﺮدازش‬
‫ﻫﺎي ﻻزم ﺑﺮ روي آن را دارا ﺧﻮاﻫﺪ ﺑﻮد‪ ، TCP/IP .‬از ﻳﻚ ﻣﺪل ارﺗﺒﺎﻃﻲ ﭼﻬﺎر ﻻﻳﻪ ﺑﻤﻨﻈﻮر ارﺳﺎل اﻃﻼﻋﺎت از‬
‫ﻣﺤﻠﻲ ﺑﻪ ﻣﺤﻞ دﻳﮕﺮ اﺳﺘﻔﺎده ﻣﻲ ﻧﻤﺎﻳﺪ‪ Application ,Transport ,Internet :‬و ‪ ، Network Interface‬ﻻﻳﻪ‬
‫ﻫﺎي ﻣﻮﺟﻮد در ﭘﺮوﺗﻜﻞ ‪ TCP/IP‬ﻣﻲ ﺑﺎﺷﻨﺪ‪ .‬ﻫﺮ ﻳﻚ از ﭘﺮوﺗﻜﻞ ﻫﺎي واﺑﺴﺘﻪ ﺑﻪ ﭘﺸﺘﻪ ‪ ، TCP/IP‬ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ‬
‫رﺳﺎﻟﺖ ﺧﻮد ‪ ،‬در ﻳﻜﻲ از ﻻﻳﻪ ﻫﺎي ﻓﻮق‪ ،‬ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ ﻛﻪ ﺗﻮﺿﻴﺢ ﻛﺎرﻛﺮد اﻳﻦ ﻻﻳﻪ ﻫﺎ در اﻳﻦ ﻣﻘﺎل ﻧﻤﻲ‬
‫ﮔﻨﺠﺪ‪.‬‬

‫ﻣﺸﺨﺺ ﻧﻤﻮدن ﺑﺮﻧﺎﻣﻪ ﻫﺎ‬
‫در ﺷﺒﻜﻪ ﻫﺎي ﻛﺎﻣﭙﻴﻮﺗﺮي ‪ ،‬ﺑﺮﻧﺎﻣﻪ ﻫﺎ ي ﻣﺘﻌﺪدي در ﻳﻚ زﻣﺎن ﺑﺎ ﻳﻜﺪﻳﮕﺮ ﻣﺮﺗﺒﻂ ﻣﻲ ﮔﺮدﻧﺪ‪ .‬زﻣﺎﻧﻴﻜﻪ ﭼﻨﺪﻳﻦ‬
‫ﺑﺮﻧﺎﻣﻪ ﺑﺮ روي ﻳﻚ ﻛﺎﻣﭙﻴﻮﺗﺮ ﻓﻌﺎل ﻣﻲ ﮔﺮدﻧﺪ ‪ ، TCP/IP ،‬ﻣﻲ ﺑﺎﻳﺴﺖ از روﺷﻲ ﺑﻪ ﻣﻨﻈﻮر ﺗﻤﺎﻳﺰ ﻳﻚ ﺑﺮﻧﺎﻣﻪ از‬

‫ﺑﺮﻧﺎﻣﻪ دﻳﮕﺮ‪ ،‬اﺳﺘﻔﺎده ﻧﻤﺎﻳﺪ‪ .‬ﺑﺪﻳﻦ ﻣﻨﻈﻮر ‪ ،‬از ﻳﻚ ﺳﻮﻛﺖ ) ‪ (Socket‬ﺑﻤﻨﻈﻮر ﻣﺸﺨﺺ ﻧﻤﻮدن ﻳﻚ ﺑﺮﻧﺎﻣﻪ‬
‫ﺧﺎص ‪ ،‬اﺳﺘﻔﺎده ﻣﻲ ﮔﺮدد‪.‬‬

‫آدرس ‪IP‬‬
‫ﺑﺮﻗﺮاري ارﺗﺒﺎط در ﻳﻚ ﺷﺒﻜﻪ ‪ ،‬ﻣﺴﺘﻠﺰم ﻣﺸﺨﺺ ﺷﺪن آدرس ﻛﺎﻣﭙﻴﻮﺗﺮﻫﺎي ﻣﺒﺪاء و ﻣﻘﺼﺪ اﺳﺖ ) ﺷﺮط اوﻟﻴﻪ‬
‫ﺑﻪ ﻣﻨﻈﻮر ﺑﺮﻗﺮاري ارﺗﺒﺎط ﺑﻴﻦ دو ﻧﻘﻄﻪ ‪ ،‬ﻣﺸﺨﺺ ﺑﻮدن آدرس ﻧﻘﺎط درﮔﻴﺮ در ارﺗﺒﺎط اﺳﺖ ( ‪ .‬آدرس ﻫﺮ ﻳﻚ‬
‫از دﺳﺘﮕﺎه ﻫﺎي درﮔﻴﺮ در ﻓﺮآﻳﻨﺪ ارﺗﺒﺎط ‪ ،‬ﺗﻮﺳﻂ ﻳﻚ ﻋﺪد ﻣﻨﺤﺼﺮﺑﻔﺮد ﻛﻪ ‪ IP‬ﻧﺎﻣﻴﺪه ﻣﻲ ﺷﻮد ‪ ،‬ﻣﺸﺨﺺ ﻣﻲ‬
‫ﮔﺮدﻧﺪ‪ .‬آدرس ﻓﻮق ﺑﻪ ﻫﺮﻳﻚ از ﻛﺎﻣﭙﻴﻮﺗﺮﻫﺎي ﻣﻮﺟﻮد در ﺷﺒﻜﻪ ﻧﺴﺒﺖ داده ﻣﻲ ﺷﻮد ‪، 10.1.1 .10 : IP .‬‬
‫ﻧﻤﻮﻧﻪ اي در اﻳﻦ زﻣﻴﻨﻪ اﺳﺖ ‪.‬‬

‫ﭘﻮرت ‪TCP/UDP‬‬
‫ﭘﻮرت ﻣﺸﺨﺼﻪ اي ﺑﺮاي ﻳﻚ ﺑﺮﻧﺎﻣﻪ و در ﻳﻚ ﻛﺎﻣﭙﻴﻮﺗﺮ ﺧﺎص اﺳﺖ‪ .‬ﭘﻮرت ﺑﺎ ﻳﻜﻲ از ﭘﺮوﺗﻜﻞ ﻫﺎي ﻻﻳﻪ‬
‫"ﺣﻤﻞ" ) ‪ TCP‬و ﻳﺎ ‪ ( UDP‬ﻣﺮﺗﺒﻂ و ﭘﻮرت ‪ TCP‬و ﻳﺎ ﭘﻮرت ‪ ، UDP‬ﻧﺎﻣﻴﺪه ﻣﻲ ﺷﻮد‪ .‬ﭘﻮرت ﻣﻲ ﺗﻮاﻧﺪ‬
‫ﻋﺪدي ﺑﻴﻦ ﺻﻔﺮ ﺗﺎ ‪ 65535‬را ﺷﺎﻣﻞ ﺷﻮد‪ .‬ﭘﻮرت ﻫﺎ ﺑﺮاي ﺑﺮﻧﺎﻣﻪ ﻫﺎي ‪ TCP/IP‬ﺳﻤﺖ ﺳﺮوﻳﺲ دﻫﻨﺪه ‪ ،‬ﺑﻌﻨﻮان‬
‫ﭘﻮرت ﻫﺎي "ﺷﻨﺎﺧﺘﻪ ﺷﺪه " ﻧﺎﻣﻴﺪه ﺷﺪه و ﺑﻪ اﻋﺪاد ﻛﻤﺘﺮ از ‪ 1024‬ﺧﺘﻢ و رزرو ﻣﻲ ﺷﻮﻧﺪ ﺗﺎ ﻫﻴﭽﮕﻮﻧﻪ ﺗﻌﺎرض‬
‫و ﺑﺮﺧﻮردي ﺑﺎ ﺳﺎﻳﺮ ﺑﺮﻧﺎﻣﻪ ﻫﺎ ﺑﻪ وﺟﻮد ﻧﻴﺎﻳﺪ‪ .‬ﻣﺜﻼ ﺑﺮﻧﺎﻣﻪ ﺳﺮوﻳﺲ دﻫﻨﺪه ‪ FTP‬از ﭘﻮرت ‪ TCP‬ﺑﻴﺴﺖ و ﻳﺎ‬
‫ﺑﻴﺴﺖ وﻳﻚ اﺳﺘﻔﺎده ﻣﻲ ﻧﻤﺎﻳﺪ‪.‬‬

‫ﺳﻮﻛﺖ )‪(Socket‬‬
‫ﺳﻮﻛﺖ ‪ ،‬ﺗﺮﻛﻴﺒﻲ از ﻳﻚ آدرس ‪ IP‬و ﭘﻮرت ‪ TCP‬وﻳﺎ ﭘﻮرت ‪ UDP‬اﺳﺖ ‪ .‬ﻳﻚ ﺑﺮﻧﺎﻣﻪ ‪ ،‬ﺳﻮﻛﺘﻲ را ﺑﺎ ﻣﺸﺨﺺ‬
‫ﻧﻤﻮدن آدرس ‪ IP‬ﻣﺮﺑﻮط ﺑﻪ ﻛﺎﻣﭙﻴﻮﺗﺮ و ﻧﻮع ﺳﺮوﻳﺲ ) ‪ TCP‬ﺑﺮاي ﺗﻀﻤﻴﻦ ﺗﻮزﻳﻊ اﻃﻼﻋﺎت و ﻳﺎ ‪ (UDP‬و ﭘﻮرﺗﻲ‬
‫ﻛﻪ ﻧﺸﺎﻧﺪﻫﻨﺪه ﺑﺮﻧﺎﻣﻪ اﺳﺖ‪ ،‬ﻣﺸﺨﺺ ﻣﻲ ﻧﻤﺎﻳﺪ‪ .‬آدرس ‪ IP‬ﻣﻮﺟﻮد در ﺳﻮﻛﺖ ‪ ،‬اﻣﻜﺎن آدرس دﻫﻲ ﻛﺎﻣﭙﻴﻮﺗﺮ‬
‫ﻣﻘﺼﺪ را ﻓﺮاﻫﻢ و ﭘﻮرت ﻣﺮﺑﻮﻃﻪ ‪ ،‬ﺑﺮﻧﺎﻣﻪ اي را ﻛﻪ داده ﻫﺎ ﺑﺮاي آن ارﺳﺎل ﻣﻲ ﮔﺮدد را ﻣﺸﺨﺺ ﻣﻲ ﻧﻤﺎﻳﺪ‪.‬‬

‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺷﺒﻜﻪ‬
‫ﺷﺒﻜﻪ ﻫﺎ )و ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺷﺒﻜﻪ( از راه درازي ﻣﺘﺠﺎوز از ‪ 20‬ﺳﺎل ﭘﻴﺶ ﻣﻲ آﻳﻨﺪ‪ .‬در اواﻳﻞ ﻣﺤﺎﺳﺒﺎت ﺗﺤﺖ‬
‫ﺷﺒﻜﻪ )در دﻫﻪ ‪ ،(80‬ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺷﺒﻜﻪ ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﺎن ﭘﻴﺸﺮﻓﺘﻪ ﻛﻪ اﺳﺎﺳﺎ ﻛﺎرﺑﺮدﻫﺎ را ﺑﺎ اﺳﺘﻔﺎده از ﺑﺮﻧﺎﻣﻪ‬
‫ﻧﻮﻳﺴﻲ ﺑﻪ زﺑﺎن ‪ C‬در ﻣﺤﻴﻂ ‪ Unix‬اﺟﺮا ﻣﻲ ﻛﺮدﻧﺪ‪ ،‬واﮔﺬار ﺷﺪه ﺑﻮد‪ .‬اﻣﺮوزه ﺷﺒﻜﻪ ﻫﺎ ﻫﻤﻪ ﺟﺎ ﻫﺴﺘﻨﺪ‪ ،‬از‬
‫ﺷﺮﻛﺘﻬﺎي ﻛﻮﭼﻚ ﮔﺮﻓﺘﻪ ﺗﺎ ﻛﺎرﺑﺮان ﻛﻮﭼﻚ ﺧﺎﻧﮕﻲ‪ .‬ﺑﻪ وﺳﻴﻠﻪ ﭼﻨﺪﻳﻦ ﻛﺎﻣﭙﻴﻮﺗﺮ ﻣﺘﺼﻞ ﺑﻪ ﻳﻜﺪﻳﮕﺮ از ﻃﺮﻳﻖ‬
‫ﺷﺒﻜﻪ ﻫﺎ‪ ،‬ﻛﺎرﺑﺮدﻫﺎي اﻃﻼﻋﻲ ﺷﺒﻜﻪ اﻟﺰﻣﺎت ﭘﺬﻳﺮﻓﺘﻪ ﺷﺪه ﻫﺴﺘﻨﺪ‪ .‬ﻛﺎرﺑﺮدﻫﺎي ﻣﻮﺟﻮد ﺑﺎﻳﺴﺘﻲ وﻳﮋﮔﻴﻬﺎي ﺷﺒﻜﻪ‬
‫را ﺑﺮاي رﻗﻴﺐ ﺑﺎﻗﻲ ﻣﺎﻧﺪن در ﺑﺎزار ﺗﺮﻛﻴﺐ ﻛﻨﻨﺪ و اﺿﺎﻓﻪ ﻛﺮدن ارﺗﺒﺎط ﺷﺒﻜﻪ ﺑﺎ ﻛﺎرﺑﺮدﻫﺎ ﺿﺮوري اﺳﺖ‪ .‬ﺑﺮﻧﺎﻣﻪ‬
‫ﻫﺎي ﺷﺒﻜﻪ ﺑﺮاي ﻫﺮ ﻛﺎري از ﺑﺎزﻳﻬﺎي ﻛﻮدﻛﺎن ﮔﺮﻓﺘﻪ ﺗﺎ ﺳﻴﺴﺘﻤﻬﺎي ﭘﺎﻳﮕﺎه داده ﺷﺮﻛﺘﻬﺎي ﭘﻴﺸﺮﻓﺘﻪ اﺳﺘﻔﺎده‬
‫ﻣﻲ‬

‫ﺷﻮﻧﺪ ‪.‬‬

‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺷﺒﻜﻪ ﻫﻤﻮاره ﻳﻚ وﻳﮋﮔﻲ ﻛﻠﻴﺪي ﺳﻴﺴﺘﻢ ﻋﺎﻣﻠﻬﺎي‬

‫‪Windows‬‬

‫ﻣﺎﻳﻜﺮوﺳﺎﻓﺖ ﺑﻮده اﺳﺖ‪.‬‬

‫ﻣﺘﺄﺳﻔﺎﻧﻪ ﺷﻤﺎ ﻣﺠﺒﻮرﻳﺪ ﻣﻔﺎﻫﻴﻢ ﭘﻴﺸﺮﻓﺘﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ‪ C‬ﻳﺎ ‪ C++‬را ﺑﺮاي ﺑﻜﺎر ﺑﺮدن وﻳﮋﮔﻴﻬﺎي ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ‬
‫ﺷﺒﻜﻪ در ﺑﺮﻧﺎﻣﻪ ﻫﺎي‬

‫‪Windows‬‬

‫ﺑﺪاﻧﻴﺪ‪ .‬ﺣﺎل ﺑﺎ اﻳﻦ وﺟﻮد زﺑﺎﻧﻬﺎي‬

‫‪.NET Framework‬‬

‫ﻛﺎر اﺿﺎﻓﻪ ﻛﺮدن‬

‫وﻳﮋﮔﻴﻬﺎي ﺷﺒﻜﻪ ﺑﻪ ﻛﺎرﺑﺮدﻫﺎي ﺷﻤﺎ را آﺳﺎﻧﺘﺮ ﻣﻲ ﻛﻨﻨﺪ ﻛﺘﺎﺑﺨﺎﻧﻪ ﻫﺎي ‪ .NET‬ﻛﻼﺳﻬﺎي ﺷﺒﻜﻪ ﻓﺮاواﻧﻲ ﻛﻪ ﻣﻲ‬
‫ﺗﻮاﻧﻨﺪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺷﺒﻜﻪ را ﺟﻤﻊ ﻛﻨﻨﺪ‪ ،‬ﻓﺮاﻫﻢ ﻣﻲ‬

‫ﻛﻨﺪ ‪.‬‬

‫ﻣﺪﻳﺮﻳﺖ ﺷﺒﻜﻪ و ﻧﻴﺎزﻫﺎي اﻣﻨﻴﺘﻲ اﻣﺮوزي ‪ ،‬ﺷﺒﻜﻪ را ذاﺗﺎ ﻣﻠﺰم ﺑﻪ ارﺗﺒﺎط ﺑﺎ وﺳﺎﻳﻞ ﺷﺒﻜﻪ و ﭘﻴﮕﻴﺮي اﻳﺴﺘﮕﺎه‬
‫ﻫﺎي ﻛﺎري در ﺷﺒﻜﻪ ﻛﺮده اﻧﺪ‪ .‬ﺗﻼش ﺑﺮاي ﻧﮕﺎرش ﺳﺮﻳﻊ ﻛﺪ ﺷﺒﻜﻪ ﺑﻲ ﻧﻘﺺ‪ ،‬وﻗﺘﻲ ﻛﻪ ﺷﻤﺎ ﺑﺎ‬

‫ﺳﺎﺧﺘﺎر ‪API‬‬

‫ﻫﺎي ﺳﻮﻛﺘﻲ ‪ C‬ﻛﺎر ﻣﻲ ﻛﻨﻴﺪ‪ ،‬ﻣﻲ ﺗﻮاﻧﺪ ﺳﺨﺖ ﺑﺎﺷﺪ و اﺟﺮاي ﻛﺎرﺑﺮدﻫﺎي ‪ Java‬اﻏﻠﺐ ﺑﻪ ﻋﻠﺖ ﻛﻨﺪ ﻛﺮدن‬
‫ﺳﺮﻋﺖ ﭘﺮدازش و ﻧﺎﭼﻴﺰ ﺑﻮدن ﭘﺸﺘﻴﺒﺎﻧﻲ‪ ، Windows‬ﺗﺠﺮﺑﻪ دردﻧﺎﻛﻲ ﻣﻲ‬

‫ﺑﺎﺷﻨﺪ ‪.‬‬

‫زﺑﺎن ‪ C#‬ﺑﺴﻴﺎري از ﻣﺸﻜﻼت ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺷﺒﻜﻪ را ﺑﺎ اﺟﺎزه ﺗﻬﻴﻪ ﺳﺮﻳﻊ ﻳﻚ ﻣﺪل اوﻟﻴﻪ و ﮔﺴﺘﺮش دادن‬
‫ﻛﺎرﺑﺮدﻫﺎي ﺷﺒﻜﻪ ﺑﺎ اﺳﺘﻔﺎده از ﻛﻼﺳﻬﺎي‬

‫‪C#‬‬

‫ﺣﻞ ﻛﺮده اﺳﺖ‪ .‬اﻟﺤﺎق ﻛﺘﺎﺑﺨﺎﻧﻪ ﻓﺮﻣﻬﺎي‬

‫‪C#‬‬

‫ﺑﺮاي ﻧﻮﺷﺘﻦ‬

‫ﻛﺪﻫﺎي ﮔﺮاﻓﻴﻜﻲ ﺑﺎ ﻛﺘﺎﺑﺨﺎﻧﻪ ﺳﻮﻛﺖ ‪ C#‬ﺑﺮاي ﻧﻮﺷﺘﻦ ﻛﺪ ﺷﺒﻜﻪ ﺳﺎزي ﻛﺎرﺑﺮدﻫﺎي اﻳﺠﺎد ﺷﺒﻜﻪ ﺣﺮﻓﻪ اي را‬
‫ﺳﺎده ﻣﻲ ﻛﻨﺪ‪ .‬ﺑﻮﺳﻴﻠﻪ ﻛﻼﺳﻬﺎي ﺷﺒﻜﻪ ‪ ، C#‬ﻧﻮﺷﺘﻦ ﻛﺪﻫﺎﻳﻲ ﻛﻪ اﻏﻠﺐ ﻧﻮﺷﺘﻨﺸﺎن ﻳﻚ روز ﻃﻮل ﻣﻲ ﻛﺸﺪ‪،‬‬
‫ﻛﻤﺘﺮ از ﻳﻚ ﺳﺎﻋﺖ ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬

‫ﻣﺮاﺣﻞ ﭘﻴﺎده ﺳﺎزي ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺳﻮﻛﺖ در ‪C#‬‬
‫ﻃﺮﻳﻘﻪ اﺗﺼﺎل‬
‫ﺑﻪ ﻃﻮر ﻛﻠﻲ ﺑﺮاي ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺳﻮﻛﺖ در ﻣﺪل ﻛﻼﻳﻨﺖ ‪ -‬ﺳﺮور ‪ ،‬ﻣﺒﺎدﻻت زﻳﺮ ﺑﻴﻦ ﻛﻼﻳﻨﺖ و ﺳﺮور رخ‬
‫ﻣﻴﺪﻫﺪ‪:‬‬
‫‪ .1‬ﺳﺮور ﺳﻮﻛﺘﻲ را ﺗﻌﺮﻳﻒ ﻣﻲ ﻛﻨﺪ‬
‫‪ .2‬ﺳﺮور ﺳﻮﻛﺖ را ﺑﻪ ﻳﻚ ‪ IP‬ﻛﻪ ﻫﻤﺎن ‪ IP‬ﺧﻮدش اﺳﺖ و ﻳﻚ ﭘﻮرت ‪ Bind‬ﻣﻴﻜﻨﺪ ﻳﺎ اﺧﺘﺼﺎص ﻣﻲ دﻫﺪ‬
‫‪ .3‬ﺳﺮور ﺑﻪ ﭘﻮرت ﮔﻮش ﻣﻲ دﻫﺪ‬
‫‪ .4‬ﻛﻼﻳﻨﺖ ﺳﻮﻛﺘﻲ را ﺗﻌﺮﻳﻒ ﻣﻴﻜﻨﺪ و ‪ IP‬و ﭘﻮرت ﺳﺮور را ﺑﻪ آن اﺧﺘﺼﺎص ﻣﻲ دﻫﺪ‬
‫‪ .5‬ﻛﻼﻳﻨﺖ درﺧﻮاﺳﺖ اﺗﺼﺎل ﻳﺎ ﻛﺎﻧﻜﺖ ﺷﺪن ﺑﻪ ﺳﺮور را ﻣﻲ دﻫﺪ‬
‫‪ .6‬ﺳﺮور درﺧﻮاﺳﺖ ﻛﻼﻳﻨﺖ را درﻳﺎﻓﺖ و آن را ﻣﻲ ﭘﺬﻳﺮد‬
‫‪ .7‬ﻛﻼﻳﻨﺖ اﻃﻼﻋﺎﺗﻲ را ارﺳﺎل ﻣﻲ ﻛﻨﺪ‬
‫‪ .8‬ﺳﺮور اﻃﻼﻋﺎت را ﻣﻲ ﮔﻴﺮد‬
‫‪ .9‬ﺳﺮور اﻃﻼﻋﺎت را ارﺳﺎل ﻣﻴﻜﻨﺪ و ﻛﻼﻳﻨﺖ آن را ﻣﻲ ﮔﻴﺮد‬
‫‪ .10‬ﺳﺮور ﺑﺴﺘﻪ ﻣﻲ ﺷﻮد‬
‫‪ .11‬ﻛﻼﻧﻴﺖ ﺑﺴﺘﻪ ﻣﻲ ﺷﻮد‬

‫ﭘﻴﺎده ﺳﺎزي اﺻﻮل اوﻟﻴﻪ‬
‫ﺣﺎل ﻛﻪ ‪ 11‬ﻣﺮﺣﻠﻪ اﺻﻠﻲ ﻻزم ﺑﺮاي اﺗﺼﺎل ﺑﻴﻦ ﻛﻼﻳﻨﺖ و ﺳﺮور را ﺗﻮﺿﻴﺢ دادﻳﻢ ﺳﻌﻲ ﻣﻲ ﻛﻨﻴﻢ ﻣﺮاﺣﻞ ﮔﻔﺘﻪ‬
‫ﺷﺪه را در ‪ C#‬ﭘﻴﺎده ﺳﺎزي ﻛﻨﻴﻢ‪ .‬در اﻳﻦ ﻣﺴﺘﻨﺪ ﭘﻴﺎده ﺳﺎزي را ﻳﻚ ﺑﺎر ﺑﻪ ﻛﻤﻚ ﺳﻮﻛﺖ ﻫﺎي ﺳﻨﻜﺮون و ﺑﺎر‬
‫دﻳﮕﺮ ﺑﻪ ﻛﻤﻚ ﺳﻮﻛﺖ ﻫﺎي آﺳﻨﻜﺮون اﻧﺠﺎم داده و ﻣﺮاﺣﻞ را ﻧﺸﺎن ﻣﻲ دﻫﻴﻢ‪.‬‬

‫ﭘﻴﺎده ﺳﺎزي ﺑﺎ ﺳﻮﻛﺖ ﻫﺎي ﺳﻨﻜﺮون‬
‫اﺑﺘﺪا ﺑﺮﻧﺎﻣﻪ ﺳﻤﺖ ﺳﺮور را ﻣﻲ‬

‫ﻧﻮﻳﺴﻢ‪.‬‬

‫در اﻳﻦ ﺑﺮﻧﺎﻣﻪ ﻣﻲ ﺑﺎﻳﺴﺖ ﻳﻚ ﭘﻮرت را ﺑﺎز ﻛﺮده و ﺑﻪ آن ﮔﻮش دﻫﻴﻢ و درﻳﺎﻓﺘﻲ را ﻧﻤﺎﻳﺶ‬
‫اﺑﺘﺪا ﻣﻲ ﺑﺎﻳﺴﺖ ﻓﻀﺎي ﻧﺎﻣﻬﺎي زﻳﺮ را ﺑﺎ اﺳﺘﻔﺎده از‬

‫دﺳﺘﻮر ‪using‬‬

‫ﺑﻪ ﻛﺎﻣﭙﺎﻳﻠﺮ ﺳﻲ ﺷﺎرپ‬

‫دﻫﻴﻢ‪.‬‬

‫ﻣﻌﺮﻓﻲ ﻛﻨﻴﻢ‪:‬‬
‫‪System.Net‬‬
‫‪System.Net.Socket‬‬
‫‪System.Text‬‬

‫اﻛﻨﻮن ﻣﺘﻐﻴﺮي ﺑﻪ ﻧﺎم را ﺑﻪ ﺻﻮرت ﺳﺮاﺳﺮي و ‪ static‬ﺗﻌﺮﻳﻒ ﻣﻴﻜﻨﻴﻢ )از آﻧﺠﺎﻳﻲ ﻛﻪ ﻣﺘﺪ ‪ Main‬ﻳﻚ‬

‫ﻣﺘﺪ ‪static‬‬

‫اﺳﺖ ﻛﻠﻴﻪ ﻣﺘﻐﻴﺮﻫﺎ و ﺗﻮاﺑﻊ ﻣﻮرد اﺳﺘﻔﺎده در آن ﻧﻴﺰ ﺑﺎﻳﺪ ‪ static‬ﺑﺎﺷﻨﺪ(‬
‫ﻣﺘﻐﻴﺮﻫﺎ ﻳﺎ ﺗﻮاﺑﻊ اﻳﺴﺘﺎ ﻣﺘﻐﻴﺮﻫﺎ و ﺗﻮاﺑﻌﻲ ﻫﺴﺘﻨﺪ ﻛﻪ در ﻳﻚ ﻛﻼس ﺑﻪ ﻃﻮر ﻣﺸﺘﺮك ﺑﻴﻦ ﻛﻠﻴﻪ اﺷﻴﺎء ﮔﺮﻓﺘﻪ ﺷﺪه‬
‫از آن ﻛﻼس وﺟﻮد دارﻧﺪ ﻧﻪ اﻳﻨﻜﻪ ﺑﻪ ازاي ﻫﺮ ﺷﻲء ﻳﻚ ﻧﻤﻮﻧﻪ از آن اﻳﺠﺎد ﺷﻮد‪ .‬دﺳﺘﺮﺳﻲ ﺑﻪ اﻳﻦ ﻣﺘﻐﻴﺮﻫﺎ از‬
‫ﻃﺮﻳﻖ ﻧﺎم ﻛﻼس ﻣﻤﻜﻦ ﺧﻮاﻫﺪ‬

‫ﺑﻮد‪.‬‬

‫ﺑﻪ ﻛﻤﻚ دﺳﺘﻮر زﻳﺮ ﻳﻚ ﺷﻲء از ﻛﻼس ﺳﻮﻛﺖ ﺑﻪ ﺻﻮرت ﺳﺮاﺳﺮي و ‪ static‬اﻳﺠﺎد‬

‫ﻣﻲ ﻛﻨﻴﻢ‪:‬‬

‫;‪static Socket sktListener‬‬

‫در ﻣﺘﺪ ‪ Main‬اﻳﻦ ﺳﻮﻛﺖ را ‪ new‬ﻣﻲ ﻛﻨﻴﻢ ﺗﺎ ﺑﻪ آن ﺣﺎﻓﻈﻪ اﺧﺘﺼﺎص داده‬

‫ﺷﻮد‪:‬‬

‫)(‪static void Main‬‬
‫{‬
‫;)‪sktListener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp‬‬

‫}‬
‫‪AddressFamily.InterNetwork‬ﺑﻪ ﻣﻌﻨﺎي اﻳﻦ اﺳﺖ ﻛﻪ از ﺷﺒﻜﻪ اي اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ داراي ‪ IP‬ﻧﺴﺨﻪ ‪4‬‬
‫اﺳﺖ‪.‬‬

‫‪SocketType.Stream‬ﺑﺮاي ﺳﻮﻛﺖ ﻫﺎﻳﻲ اﺳﺖ ﻛﻪ ﻣﻲ ﺧﻮاﻫﻨﺪ ﺑﻪ ﺻﻮرت ‪ Stream‬داده ﻫﺎ را ﺗﺒﺎدل ﻛﻨﻨﺪ و‬
‫‪ ProtocolType.Tcp‬ﻧﻮع ﭘﺮوﺗﻜﻞ ﻣﺎ را ﻣﺸﺨﺺ ﻣﻲ‬

‫ﻛﻨﺪ‪.‬‬

‫اﻛﻨﻮن ﻣﻲ ﺑﺎﻳﺪ آدرس ‪ IP‬و ﻳﻚ ‪ Port‬ﺑﻪ ﺳﻮﻛﺖ ﻣﺎن اﺧﺘﺼﺎص‬

‫دﻫﻴﻢ‪:‬‬

‫;)‪IPEndPoint ipLocal = new IPEndPoint(IPAddress.Any, 1800‬‬
‫;)‪sktListener.Bind(ipLocal‬‬

‫از آﻧﺠﺎﻳﻲ ﻛﻪ اﻳﻦ ﺑﺮﻧﺎﻣﻪ در ﺳﻤﺖ ﺳﺮور اﺟﺮا ﻣﻴﺸﻮد آدرس ‪ IP‬ﺧﺎﺻﻲ ﺑﻪ آن ﻧﻤﻲ دﻫﻴﻢ و ﭘﻮرت ‪ 1800‬را ﺑﺎز‬
‫ﻣﻴﻜﻨﻴﻢ‪ .‬ﻛﻼس ‪ IPEndPoint‬ﺑﺮاي ﻣﺸﺨﺺ ﻧﻤﻮدن ﻳﻚ ﻧﻮد ﻳﺎ ﻳﻚ ﻛﺎﻣﭙﻴﻮﺗﺮ در ﺷﺒﻜﻪ ﺑﻪ ﻛﺎر ﻣﻲ‬
‫اﻛﻨﻮن زﻣﺎن ﮔﻮش دادن ﺑﻪ ﭘﻮرت‬

‫رود‪.‬‬

‫اﺳﺖ‪:‬‬
‫;)‪sktListener.Listen(100‬‬

‫ﻋﺪد ‪ 100‬ﻧﺸﺎﻧﻪ آن اﺳﺖ ﻛﻪ ﺣﺪاﻛﺜﺮ ‪ connection 4‬ﻣﻲ ﺗﻮاﻧﻨﺪ در ﺻﻒ ﻗﺮار‬

‫ﮔﻴﺮﻧﺪ‪.‬‬

‫اﮔﺮ در اﻳﻦ ﻟﺤﻀﻪ در ‪ command prompt‬دﺳﺘﻮر ‪ netstat –an‬را ﺗﺎﻳﭗ ﻛﻨﻴﺪ ﻣﻴﺘﻮاﻧﻴﺪ ﺑﺒﻴﻨﻴﺪ ﻛﻪ ﭘﻮرت ‪ 1800‬ﺑﺎز‬
‫ﺷﺪه و در ﺣﺎل ﮔﻮش دادن‬

‫اﺳﺖ‪.‬‬

‫ﺣﺎل ﻣﻲ ﺑﺎﻳﺪ ﺗﻘﺎﺿﺎي ﻛﺎﻧﻜﺖ ﺷﺪن ﻛﻼﻳﻨﺖ را‬

‫ﺑﭙﺬﻳﺮﻳﻢ‪:‬‬
‫;)(‪sktListener = sktListener.Accept‬‬

‫ﺣﺎل ﺑﺮاي ﮔﺮﻓﺘﻦ داده ﻫﺎ ‪ ،‬ﻣﻲ ﺑﺎﻳﺴﺖ ﻳﻚ ﺑﺎﻓﺮ ﺗﻌﺮﻳﻒ ﻧﻤﺎﻳﻴﻢ‬
‫ﻧﻜﺘﻪ ‪ :‬در ﺳﻮﻛﺖ ﭘﺮوﮔﺮﻣﻴﻨﮓ ‪ ،‬داده ﻫﺎ ﺑﻪ ﺻﻮرت آراﻳﻪ اي از ﺑﺎﻳﺖ ﻫﺎ ﻣﻨﺘﻘﻞ ﻣﻲ ﺷﻮﻧﺪ‪ .‬ﺑﺮاي ارﺳﺎل رﺷﺘﻪ‬
‫ﻫﺎي ﻳﻮﻧﻴﻜﺪ و ‪ ....‬ﺑﺎﻳﺴﺖ آﻧﻬﺎ را ﻛﺪ ﮔﺬاري ﻛﻨﻴﻢ ‪ .‬ﺑﺮاي ﻛﺪ ﮔﺬاري و ﻛﺪ ﮔﺸﺎﻳﻲ از ﻛﻼس ‪ System.Text‬و‬
‫ﻣﺘﺪﻫﺎي آن اﺳﺘﻔﺎده ﻛﻨﻴﻢ ‪.‬ﻣﺜﻼ دﺳﺘﻮر زﻳﺮ رﺷﺘﻪ ‪ salam‬را ﺑﺎ ﻓﺮﻣﺖ ‪ Ascii‬ﺑﻪ آراﻳﻪ اي از ﺑﺎﻳﺖ ﻫﺎ ﺗﺒﺪﻳﻞ ﻣﻴﻜﻨﺪ‬
‫;)"‪byte[] byt = Encoding.ASCII.GetBytes("salam‬‬

‫و ﻣﺘﺪ زﻳﺮ آن را‬

‫رﻣﺰﮔﺸﺎﻳﻲ ﻣﻴﻜﻨﺪ‪:‬‬
‫;)‪string str = Encoding.ASCII.GetString(byt‬‬

‫ﻣﺎ ﻋﻤﻞ رﻣﺰﻧﮕﺎري را ﻣﻮﻗﻊ ارﺳﺎل داده ﻫﺎ و ﻋﻤﻞ رﻣﺰ ﮔﺸﺎﻳﻲ را ﻣﻮﻗﻊ درﻳﺎﻓﺖ آﻧﻬﺎ اﻧﺠﺎم ﻣﻲ‬
‫اﻛﻨﻮن ﻣﻲ ﺧﻮاﻫﻴﻢ داده ﻫﺎ را درﻳﺎﻓﺖ ﻛﺮده و رﻣﺰ ﮔﺸﺎﻳﻲ‬

‫دﻫﻴﻢ‪.‬‬

‫ﻛﻨﻴﻢ‪:‬‬

‫;]‪byte[] buffer = new byte[500‬‬
‫;)‪sktListener.Receive(buffer‬‬
‫;)‪string Data = Encoding.ASCII.GetString(buffer‬‬

‫ﺣﺎل ﻣﻴﺘﻮاﻧﻴﻢ داده ﻫﺎ را ﭘﺮدازش‬

‫ﻛﻨﻴﻢ‪:‬‬
‫;)‪Console.WriteLine(Data‬‬

‫ﭘﻴﺎده ﺳﺎزي ﺑﺎ ﺳﻮﻛﺖ ﻫﺎي آﺳﻨﻜﺮون‬
‫ﻛﺪﻫﺎﻳﻲ ﻛﻪ ﺗﺎ ﺑﻪ اﻳﻨﺠﺎ دﻳﺪﻳﻢ ﺑﺮاي اﻳﺠﺎد ﺳﻮﻛﺖ ﻫﺎي ﻫﻤﮕﺎم ﻳﺎ ﺳﻨﻜﺮون ﺑﻮده اﺳﺖ‪ .‬اﻳﻦ ﺳﻮﻛﺖ ﻫﺎ در ﺑﺮﻧﺎﻣﻪ‬
‫ﻫﺎي وﻳﻨﺪوز و ﻛﻼ ﺳﻴﺴﺘﻢ ﻫﺎي ﻣﺎﻟﺘﻲ ﺗﺴﻚ ﻛﺎرﺑﺮدي ﻧﺪارﻧﺪ‪ .‬ﭼﺮا ﻛﻪ ﺑﺎﻟﻔﺮض در زﻣﺎﻧﻲ از ﻣﺘﺪ‬

‫‪accept‬‬

‫اﺳﺘﻔﺎده ﻧﻤﻮده اﻳﻢ‪ ،‬در اﻳﻦ ﺣﺎﻟﺖ ﺑﺮﻧﺎﻣﻪ ﺗﺎ رﺳﻴﺪن ﻳﻚ ﺳﻮﻛﺖ ﺑﻪ آن ﻗﻔﻞ ﺷﺪه و ﻗﺎدر ﺑﻪ اﻧﺠﺎم ﻛﺎري‬

‫ﻧﻴﺴﺖ‪.‬‬

‫در ﺳﻮﻛﺖ ﻫﺎي آﺳﻨﻜﺮون از ﻣﺘﺪﻫﺎي آﺳﻨﻜﺮون ﺑﺮاي ﮔﻮش دادن ‪ ،‬ارﺳﺎل ‪ ،‬درﻳﺎﻓﺖ و ‪...‬اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻴﻢ‪ .‬در‬
‫اﻳﻦ ﻣﺴﺘﻨﺪ ‪ ،‬ﻳﻚ ﺑﺮﻧﺎﻣﻪ ﺳﻤﺖ ﺳﺮور ﺑﻪ ﺻﻮرت آﺳﻨﻜﺮون ﻃﺮاﺣﻲ ﻣﻴﻜﻨﻴﻢ ﻛﻪ ﻗﺎدر ﺑﻪ ﮔﻮش دادن ﺑﻪ ﻳﻚ‬
‫ﻛﻼﻳﻨﺖ‬

‫اﺳﺖ‪.‬‬

‫ﻧﻜﺘﻪ ‪ :‬ﻗﺒﻞ از اداﻣﻪ ‪ ،‬آﺷﻨﺎﻳﻲ ﺑﺎ ‪ delegate‬ﻫﺎ اﻟﺰاﻣﻲ اﺳﺖ‪ .‬وﻟﻲ اﮔﺮ ﺑﺨﻮاﻫﻴﻢ در ﻳﻚ ﺟﻤﻠﻪ ‪ Delegate‬ﻫﺎ را‬
‫ﺗﻌﺮﻳﻒ ﻛﻨﻴﻢ ﻣﻴﺘﻮاﻧﻴﻢ ﺑﮕﻮﻳﻴﻢ ‪ delegate‬در ﺣﻘﻴﻘﺖ ﭼﻴﺰي ﻧﻴﺴﺖ ﺟﺰ اﺷﺎره ﮔﺮ ﺑﻪ‬

‫ﺗﺎﺑﻊ !‬

‫در ﺳﻮﻛﺖ ﻫﺎي آﺳﻨﻜﺮون ‪ ،‬از ‪ delegate‬اي ﺑﻪ ﻧﺎم ‪ AsyncCallback‬اﺳﺘﻔﺎده ﻣﻴﻜﻨﻴﻢ‪ .‬اﻳﻦ ‪ Delegate‬ﺑﻪ ﺗﺎﺑﻌﻲ‬
‫اﺷﺎره ﻣﻴﻜﻨﺪ ﻛﻪ ﺗﻨﻬﺎ ﻳﻚ آرﮔﻮﻣﺎن ورودي از ﻧﻮع ‪ IAsyncResult‬دارد‪ .‬ﻣﺘﺪﻫﺎﻳﻲ ﻛﻪ ﺑﻪ ﺻﻮرت آﺳﻨﻜﺮون ﻛﺎر‬
‫ﻣﻲ ﻛﻨﻨﺪ ‪ ،‬اﻃﻼﻋﺎت ﻣﻮرد ﻧﻈﺮ ﺧﻮد را ﺑﻪ ﺻﻮرت ﻳﻚ ﺷﻲ از اﻳﻦ ﺗﻮع ﺑﻪ ﺗﺎﺑﻊ ﻣﻮرد ﻧﻈﺮ ﺧﻮد ارﺳﺎل‬
‫ﻧﻜﺘﻪ ‪ :‬ﻣﺘﺪﻫﺎي آﺳﻨﻜﺮون ﺑﺎ ﭘﻴﺸﻮﻧﺪﻫﺎي ‪Begin‬و ‪ End‬ﺷﺮوع‬

‫ﻣﻴﻜﻨﻨﺪ‪.‬‬

‫ﻣﻴﮕﺮدﻧﺪ‪.‬‬

‫ﺑﺮاي ﻧﻮﺷﺘﻦ ﺑﺮﻧﺎﻣﻪ ‪ ،‬اﺑﺘﺪا ﻳﻚ ﺳﻮﻛﺖ ﺗﻌﺮﻳﻒ ﻣﻴﻜﻨﻴﻢ ﻛﻪ ﻋﻤﻞ ﮔﻮش دادن را اﻧﺠﺎم‬

‫دﻫﺪ ‪:‬‬

‫‪Socket Mainlistener = new Socket(AddressFamily.InterNetwork, SocketType.Stream,‬‬
‫;)‪ProtocolType.Tcp‬‬

‫ﺳﭙﺲ ﻋﻤﻠﻴﺎت ﻣﻌﻤﻮل را ﺑﺮ روي ﺳﻮﻛﺖ اﻧﺠﺎم‬

‫ﻣﻴﺪﻫﻴﻢ‪:‬‬

‫;)‪IPEndPoint server = new IPEndPoint(IPAddress.Any, 1800‬‬
‫;)‪Mainlistener.Bind(server‬‬

‫ﻫﻤﺎﻧﮕﻮﻧﻪ ﻛﻪ ﻣﻴﺒﻴﻨﻴﺪ ‪ ،‬در اﻳﻦ ﺑﺮﻧﺎﻣﻪ ﺳﻮﻛﺖ ﻣﻮرد ﻧﻈﺮ ﻣﺎ ﺑﻪ ﭘﻮرت ‪ 1800‬ﮔﻮش‬

‫ﻣﻴﺪﻫﺪ‪.‬‬

‫اﻳﺠﺎد ﻛﺮده و آن را ﺑﻪ ﺗﺎﺑﻊ ﭘﺮدازﺷﮕﺮ ﻛﻪ در اﻳﻦ ﻣﺜﺎل‬

‫اﻛﻨﻮن زﻣﺎن آن اﺳﺖ ﻛﻪ ﻳﻚ‬
‫‪AcceptCallBack‬ﻧﺎم دارد ‪ ،‬ﻣﻨﺘﺴﺐ ﻛﻨﻴﻢ ‪.‬‬

‫‪delegate‬‬

‫;)‪AsyncCallback callBackMethod = new AsyncCallback(AcceptCallback‬‬

‫اﻛﻨﻮن ﺑﺎﻳﺪ ﺳﻮﻛﺖ ﺗﻌﺮﻳﻒ ﺷﺪه ﺑﻪ ﺻﻮرت ﻏﻴﺮ ﻫﻤﮕﺎم ) آﺳﻨﻜﺮون( ﺷﺮوع ﺑﻪ ﮔﻮش دادن ﺑﻪ ﭘﻮرت‬

‫ﻛﻨﺪ‪:‬‬

‫;)‪Mainlistener.Listen(4‬‬
‫;)‪Mainlistener.BeginAccept(AcceptCallback,Mainlistener‬‬

‫در اﻳﻦ ﻣﺜﺎل ‪ ،‬ﻣﺸﺨﺺ ﻛﺮده اﻳﻢ ﻛﻪ ﺳﻮﻛﺖ ﺷﺮوع ﺑﻪ ﻋﻤﻞ ﮔﻮش دادن و اﻧﺘﻈﺎر ﻛﻨﺪ و ﺳﭙﺲ ﺑﻪ ﻣﺤﺾ‬
‫ﻛﺎﻧﻜﺖ ﺷﺪن ﻳﻚ ﻛﻼﻳﻨﺖ ﺑﻪ ﻛﺎﻣﭙﻴﻮﺗﺮ ﻣﺎ ‪ ،‬ﺗﺎﺑﻊ ‪AcceptCallBack‬اﺟﺮا ﮔﺮدد و ﺑﻪ اﻣﻮري ﻛﻪ ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﻴﻢ‬
‫رﺳﻴﺪﮔﻲ ﻛﻨﺪ‪.‬‬
‫ﻧﻜﺘﻪ ‪ :‬ﭘﺎراﻣﺘﺮ دوم ﺗﺎﺑﻊ ‪ ، BeginAccept‬ﺷﻲء اي اﺳﺖ ﺑﺮاي ارﺳﺎل داده ﻫﺎي وﺿﻌﻴﺖ ﺳﻮﻛﺖ ﺑﻪ ﺗﺎﺑﻌﻲ ﻛﻪ ﺑﻪ‬
‫ﺳﻮﻛﺖ رﺳﻴﺪﮔﻲ ﻣﻲ ﻛﻨﺪ ‪ .‬در اﻳﻦ ﺟﺎ اﻳﻦ ﺷﻲء ﺧﻮد ﺳﻮﻛﺖ اﺳﺖ ‪ .‬اﮔﺮ ﺳﻮﻛﺖ را ﺑﻪ ﺻﻮرت ﺳﺮاﺳﺮي ﺗﻌﺮﻳﻒ‬
‫ﻣﻲ ﻛﺮدﻳﻢ ‪ ،‬ﻧﻴﺎز ﺑﻪ ارﺳﺎل اﻳﻦ ﺷﻲء ﻧﺒﻮد و ﺑﻪ ﺟﺎي آن ‪ null‬ﻗﺮار ﻣﻲ دادﻳﻢ‪ .‬ﺷﻲء ﻣﺮﺑﻮﻃﻪ در ﻗﺎﻟﺐ ﻳﻚ ﺷﻲء‬
‫از ﻛﻼس ‪ IAsyncResult‬ارﺳﺎل ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬
‫ﺗﺎﺑﻊ ‪ AcceptCallback‬ﺑﺎﻳﺴﺘﻲ اﻳﻨﮕﻮﻧﻪ ﺗﻌﺮﻳﻒ‬

‫ﺷﻮد ‪.‬‬
‫)‪private void AcceptCallback(IAsyncResult ar‬‬
‫{‬
‫‪...‬‬
‫{‬

‫در اﻳﻦ ﺗﺎﺑﻊ ‪ ،‬آرﮔﻮﻣﺎﻧﻲ از ﻧﻮع ‪ IAsyncResult‬وﺟﻮد دارد‪ .‬اﻳﻦ آرﮔﻮﻣﺎن اﻃﻼﻋﺎت وﺿﻌﻴﺖ ﻓﺮاﺧﻮان ﺗﺎﺑﻊ‬
‫آﺳﻨﻜﺮون ﻛﻪ در اﻳﻨﺠﺎ ﻳﻚ ﺳﻮﻛﺖ اﺳﺖ را ﻧﮕﻬﺪاري ﻣﻲ ﻛﻨﺪ‪ .‬اﺑﺘﺪا اﻳﻦ اﻃﻼﻋﺎت را اﺳﺘﺨﺮاج ﻣﻲ ﻛﻨﻴﻢ‪:‬‬
‫;)‪Socket temp = ((Socket)ar.AsyncState‬‬

‫ﺳﭙﺲ ﺑﻪ ﮔﻮش دادن ﺑﺮاي ﭘﺬﻳﺮﻓﺘﻦ ﻛﻼﻳﻨﺖ ﺧﺎﺗﻤﻪ ﻣﻴﺪﻫﻴﻢ ﭼﺮا ﻛﻪ اﻛﻨﻮن دﻳﮕﺮ ﻛﻼﻳﻨﺖ ﻣﻮرد ﻧﻈﺮ ﺑﻪ ﺳﺮور‬
‫ﻛﺎﻧﻜﺖ ﺷﺪه و آﻣﺎده ﺑﺮاي ارﺳﺎل اﻃﻼﻋﺎت اﺳﺖ‪:‬‬
‫;)‪Socket worker = temp.EndAccept(ar‬‬

‫ﻧﻜﺘﻪ ‪ :‬دو دﺳﺘﻮر ﻗﺒﻞ را ﻣﻴﺘﻮاﻧﺴﺘﻴﻢ در ﻗﺎﻟﺐ ﻳﻚ دﺳﺘﻮر و ﺑﻪ اﻳﻦ ﺷﻜﻞ‬

‫ﺑﻨﻮﻳﺴﻴﻢ‪:‬‬

‫;)‪Socket temp = ((Socket)ar.AsyncState).EndAccept(ar‬‬

‫اﻛﻨﻮن ﻛﻪ ارﺗﺒﺎط ﻛﻼﻳﻨﺖ ﺑﺎ ﺑﺮﻧﺎﻣﻪ ﻣﺎ ﺑﺮﻗﺮار ﮔﺮدﻳﺪه اﺳﺖ ‪ ،‬ﻛﺎﻓﻲ اﺳﺖ ﺗﺎ ﺑﻪ ﺻﻮرت آﺳﻨﻜﺮون ﺑﻪ درﻳﺎﻓﺖ‬
‫اﻃﻼﻋﺎت ﻣﺸﻐﻮل ﺷﻮﻳﻢ‪ .‬ﺑﺎز ﻫﻢ ﻣﺎﻧﻨﺪ ﻗﺴﻤﺖ ﻗﺒﻞ‪ ،‬از ﻣﺘﺪﻫﺎي آﺳﻨﻜﺮون اﺳﺘﻔﺎده ﻛﺮده و ﺗﺎﺑﻌﻲ ﺗﻌﺮﻳﻒ ﻣﻲ‬
‫ﻛﻨﻴﻢ ﻛﻪ ﺑﻪ ﻣﺤﺾ درﻳﺎﻓﺖ اﻃﻼﻋﺎت ﻓﺮاﺧﻮاﻧﻲ ﮔﺮدﻳﺪه و ﻋﻤﻠﻴﺎت ﻣﻮرد ﻧﻈﺮ ﻣﺎ را اﻧﺠﺎم دﻫﺪ ‪.‬‬
‫ﻧﻜﺘﻪ اي ﻛﻪ ﺑﺴﻴﺎر ﺣﺎﺋﺰ اﻫﻤﻴﺖ اﺳﺖ اﻳﻦ ﻛﻪ ﺑﺎﻳﺴﺘﻲ از ﻳﻚ ﺑﺎﻓﺮ ﺑﺮاي ذﺧﻴﺮه اﻃﻼﻋﺎت درﻳﺎﻓﺘﻲ اﺳﺘﻔﺎده ﻛﻨﻴﻢ‪.‬‬
‫اﻳﻦ ﺑﺎﻓﺮ ﻛﻪ در ﺣﻘﻴﻘﺖ آراﻳﻪ اي از ﺑﺎﻳﺘﻬﺎ اﺳﺖ ﺑﻪ ﺻﻮرت ﻳﻚ آراﻳﻪ ﺳﺮاﺳﺮي ﺗﻌﺮﻳﻒ ﻣﻴﻜﻨﻴﻢ‪:‬‬
‫;]‪byte[] buffer = new byte[1024‬‬

‫ﻧﻜﺘﻪ ‪ :‬ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ اﻳﻦ ﻛﻪ در اﻳﻦ ﺑﺮﻧﺎﻣﻪ ﺻﺮﻓﺎ ﻳﺎ ﻳﻚ ﻛﻼﻳﻨﺖ ﻛﺎر ﻣﻴﻜﻨﻴﻢ ‪ ،‬ﺳﺮاﺳﺮي ﺑﻮدن ﺑﺎﻓﺮ ﻣﺸﻜﻠﻲ اﻳﺠﺎد‬
‫ﻧﻤﻲ ﻛﻨﺪ‪ ،‬اﻣﺎ ﭼﻨﺎﻧﭽﻪ ﻗﺼﺪ داﺷﺘﻴﻢ ﺑﺎ ﭼﻨﺪ ﻛﻼﻳﻨﺖ ﻛﺎر ﻛﻨﻴﻢ ﺑﺮاي ﻫﺮﻳﻚ ﻣﻲ ﺑﺎﻳﺴﺖ ﺑﺎﻓﺮ ﻣﺨﺼﻮص ﺑﻪ‬
‫ﺧﻮدش را ﺗﻌﺮﻳﻒ ﻣﻴﻜﺮدﻳﻢ ﻛﻪ اﺻﻮﻻ ﭘﻴﺎده ﺳﺎزي آن ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﮔﻮﻧﻪ اي دﻳﮕﺮ ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬
‫ﺑﺮاي درﻳﺎﻓﺖ اﻃﻼﻋﺎت ﺑﻪ ﺻﻮرت آﺳﻨﻜﺮون‪ ،‬از ﻣﺘﺪ ‪ BeginReceive‬اﺳﺘﻔﺎده ﻣﻴﻜﻨﻴﻢ‪ .‬اﻟﺒﺘﻪ ﺑﺎﻳﺴﺘﻲ ﺑﺎﻓﺮ‪ ،‬اﻧﺪﻳﺲ‬
‫اوﻟﻴﻪ اي ﻛﻪ ﻣﻲ ﺧﻮاﻫﻴﻢ ﺑﺎﻓﺮ از آﻧﺠﺎ ﭘﺮ ﺷﻮد و ﻫﻤﭽﻨﻴﻦ اﻧﺪﻳﺲ ﺣﺪ ﻧﻬﺎﻳﻲ ﺑﺎﻓﺮ را ﻣﺸﺨﺺ ﻛﻨﻴﻢ‪.‬‬
‫;)‪AsyncCallback ReceiveMethod = new AsyncCallback(ReceiveCallBack‬‬
‫‪worker.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None,new‬‬
‫;)‪ReceiveMethod, worker‬‬

:‫اﺳﺖ‬

‫ ﺑﻪ اﻳﻦ ﺻﻮرت‬AcceptCallback ‫ ﻣﺘﺪ‬، ‫ﭘﺲ ﺗﺎ اﻳﻨﺠﺎ‬

private void AcceptCallback(IAsyncResult ar)
{
Socket temp = ((Socket)ar.AsyncState);
Socket worker = temp.EndAccept(ar);
AsyncCallback ReceiveMethod = new AsyncCallback(ReceiveCallBack);
worker.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None,new
ReceiveMethod, worker);
}
:‫ﻣﻲ ﻛﻨﻴﻢ‬

‫ را ﺗﻌﺮﻳﻒ‬ReceiveCallBack ‫اﻛﻨﻮن ﻣﺘﺪ‬

private void ReceiveCallBack(IAsyncResult ar)
{
...
{
:‫آورﻳﻢ‬

‫ اﺑﺘﺪا اﻃﻼﻋﺎت وﺿﻌﻴﺖ را ﺑﺪﺳﺖ ﻣﻲ‬، ‫درون اﻳﻦ ﻣﺘﺪ‬

Socket worker = ((Socket)ar.AsyncState);

‫ اﻳﻦ ﻛﺎر را‬.‫ﺳﭙﺲ ﺑﻪ ﮔﻮش دادن ﺑﻪ ﺻﻮرت ﻣﻮﻗﺖ ﺧﺎﺗﻤﻪ ﻣﻲ دﻫﻴﻢ ﺗﺎ ﺑﺘﻮاﻧﻴﻢ داده ﻫﺎي ﻓﻌﻠﻲ را ﭘﺮدازش ﻛﻨﻴﻢ‬
:‫ ﻣﻘﺪار ﺑﺎزﮔﺸﺘﻲ اﻳﻦ ﻣﺘﺪ ﺗﻌﺪاد ﺑﺎﻳﺘﻬﺎي درﻳﺎﻓﺖ ﺷﺪه ﻣﻲ ﺑﺎﺷﺪ‬. ‫ اﻧﺠﺎم ﻣﻴﺪﻫﻴﻢ‬EndReceive ‫ﺑﺎ ﻣﺘﺪ‬
int bytesReceived = worker.EndReceive(ar);

‫ﺣﺎل ﻣﻲ ﺑﺎﻳﺴﺖ اﻃﻼﻋﺎت درﻳﺎﻓﺖ ﺷﺪه ﻛﻪ ﺑﻪ ﺻﻮرت آراﻳﻪ اي ﺑﺎﻳﺘﻬﺎ درون ﺑﺎﻓﺮ ﻫﺴﺘﻨﺪ را ﭘﺮدازش ﻛﺮده و‬
:‫( ﺗﺒﺪﻳﻞ ﻛﻨﻴﻢ‬string) ‫ﺟﻬﺖ ﻧﻤﺎﻳﺶ ﺑﻪ رﺷﺘﻪ‬
string str = System.Text.UTF8Encoding.UTF8.GetString(buffer);

‫ را ﺑﺮاي ﺷﻤﺎ‬Client ‫ و ﻳﻚ‬Server ‫در ﺗﻜﻤﻴﻞ ﻣﻄﺎﻟﺐ ﮔﻔﺘﻪ ﺷﺪه در اﻳﻨﺠﺎ ﻳﻚ ﻣﺜﺎل ﺳﺎده آورده اﻳﻢ ﻛﻪ ﻳﻚ‬
:‫ اﻳﺠﺎد ﻣﻲ ﻛﻨﺪ‬Thread ‫ﺑﻪ ازاي ﻫﺮ اﺗﺼﺎل از ﺳﻤﺖ ﻛﻼﻳﻨﺖ ﻳﻚ‬Threading ‫ﻣﻲ ﺳﺎزد و ﺑﺎ اﺳﺘﻔﺎده از‬
class TcpServer
{
private TcpListener _tcpListener;

public TcpServer(int port)
{
_tcpListener = new TcpListener(port);
}
public void BeginToListen(int intMaxconn)
{
_tcpListener.Start(intMaxconn);
while (true)
{
if (!_tcpListener.Pending())
{
Console.WriteLine("Waiting for new request...");
Thread.Sleep(1000);
}
else
{
Console.WriteLine("Recieve new pending..");
ClientConnectionThread clientConn = new ClientConnectionThread(_tcpListener);
Thread thread = new Thread(new ThreadStart(clientConn.HandleConnection));
thread.Start();
}
}
}
}

‫ﻳﻚ ﻛﺪ ﺳﺎده‬
‫ﺣﺎل ﻛﻪ ﻣﺮاﺣﻞ اﺻﻠﻲ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺳﻮﻛﺖ ﺷﺮح داده ﺷﺪ‪ ،‬در اداﻣﻪ ﻳﻚ ﻛﺪ ﺳﺎده ﺑﻪ زﺑﺎن ‪ C#‬ﺑﺮاي ارﺳﺎل‬
‫ﻣﺘﻦ در ﻳﻚ ﺷﺒﻜﻪ ﻣﺤﻠﻲ ﺑﺎ اﺳﺘﻔﺎده از ﻣﻄﺎﻟﺐ ﮔﻔﺘﻪ ﺷﺪه آورده ﺷﺪه اﺳﺖ‪.‬‬
‫ﻣﻬﻢ ﺗﺮﻳﻦ ﻛﻼس ﺑﻪ ﻛﺎر رﻓﺘﻪ در اﻳﻦ ﻛﺪ‪ ،‬ﻛﻼس ‪ TcpListener‬اﺳﺖ ﻛﻪ ﻳﻜﻲ از ﻣﻬﻢ ﺗﺮﻳﻦ وﻇﺎﻳﻒ ارﺗﺒﺎط‬
‫ﺑﻴﻦ دو ﻛﺎﻣﭙﻴﻮﺗﺮ را ﺑﺎ اﺳﺘﻔﺎده از ﭘﺮوﺗﻜﻞ ‪ TCP‬را ﻓﺮاﻫﻢ ﻣﻲ ﻧﻤﺎﻳﺪ‪ .‬ﻫﻤﺎن ﮔﻮﻧﻪ ﻛﻪ در ﻣﻄﺎﻟﺐ ﻗﺒﻠﻲ ﻧﻴﺰ ذﻛﺮ ﺷﺪ‬
‫ﺑﺎﻳﺪ ﻳﻚ ﺷﻲ از اﻳﻦ ﻛﻼس ﺗﻌﺮﻳﻒ ﻧﻤﺎﻳﻴﻢ ﻛﻪ اﻳﻦ ﺷﻲ ﺑﻪ ﻛﻤﻚ ﻳﻚ آدرس ‪ IP‬و ﻳﻚ ﭘﻮرت ﺑﻪ ﭘﻴﻐﺎم ﻫﺎي‬
‫رﺳﻴﺪه از آدرس و از آن ﭘﻮرت ﮔﻮش داده و ﻣﻨﺘﻈﺮ ﺑﺮﻗﺮاري ارﺗﺒﺎط ﻣﻲ ﻣﺎﻧﺪ‪.‬‬
‫ﻧﻤﻮﻧﻪ ﻛﺪ زﻳﺮ ﺑﻪ ﻛﻤﻚ اﻳﻦ ﻛﻼس ﺑﻪ ﭘﻴﺎم ﻫﺎي رﺳﻴﺪه از ﭘﻮرت ‪ 13000‬از آدرس ‪ Localhost‬ﮔﻮش ﻣﻲ ﻛﻨﺪ‬
‫و ارﺗﺒﺎط ﺑﺎ ﺳﺎﻳﺮ ﻛﻼﻳﻨﺖ ﻫﺎ را ﺑﺮﻗﺮار ﻣﻲ ﻛﻨﺪ‪:‬‬
‫;‪using System‬‬
‫;‪using System.IO‬‬
‫;‪using System.Net‬‬
‫;‪using System.Net.Sockets‬‬
‫;‪using System.Text‬‬
‫‪class MyTcpListener‬‬
‫{‬
‫)(‪public static void Main‬‬
‫{‬
‫;‪TcpListener server=null‬‬
‫‪try‬‬
‫{‬
‫‪// Set the TcpListener on port 13000.‬‬
‫;‪Int32 port = 13000‬‬
‫;)"‪IPAddress localAddr = IPAddress.Parse("127.0.0.1‬‬
‫;)‪// TcpListener server = new TcpListener(port‬‬
‫;)‪server = new TcpListener(localAddr, port‬‬
‫‪// Start listening for client requests.‬‬
‫;)(‪server.Start‬‬
‫‪// Buffer for reading data‬‬

Byte[] bytes = new Byte[256];
String data = null;
// Enter the listening loop.
while(true)
{
Console.Write("Waiting for a connection... ");
// Perform a blocking call to accept requests.
// You could also user server.AcceptSocket() here.
TcpClient client = server.AcceptTcpClient();
Console.WriteLine("Connected!");
data = null;
// Get a stream object for reading and writing
NetworkStream stream = client.GetStream();
int i;
// Loop to receive all the data sent by the client.
while((i = stream.Read(bytes, 0, bytes.Length))!=0)
{
// Translate data bytes to a ASCII string.
data = System.Text.Encoding.ASCII.GetString(bytes, 0, i);
Console.WriteLine("Received: {0}", data);
// Process the data sent by the client.
data = data.ToUpper();
byte[] msg = System.Text.Encoding.ASCII.GetBytes(data);
// Send back a response.
stream.Write(msg, 0, msg.Length);
Console.WriteLine("Sent: {0}", data);
}
// Shutdown and end connection
client.Close();
}

}
catch(SocketException e)
{
Console.WriteLine("SocketException: {0}", e);
}
finally
{
// Stop listening for new clients.
server.Stop();
}

Console.WriteLine("\nHit enter to continue...");
Console.Read();
}

‫ﺿﻤﻴﻤﻪ‪ :‬ﻣﻌﺮﻓﻲ ﻣﺨﺘﺼﺮ ﻓﻀﺎﻫﺎي ﻧﺎﻣﻲ اﺳﺘﻔﺎده ﺷﺪه‬
‫‪ ، System.Net‬ﺷﺎﻣﻞ ﻧﻮع ﻫﺎﺋﻲ ﺑﻤﻨﻈﻮر دﺳﺘﻴﺎﺑﻲ ﺑﻪ ﭼﻨﺪﻳﻦ ﭘﺮوﺗﻜﻞ ﻣﺘﺪاول ﻧﻈﻴﺮ‪ HTTP :‬و‬
‫اﺳﺖ ‪ namespace .‬ﻓﻮق ‪ ،‬ﻫﻤﭽﻨﻴﻦ ﺷﺎﻣﻞ ﻛﻼس ﻫﺎي ‪ WebRequest‬و ‪ WebResponse‬ﺑﻮده ﻛﻪ اﻣﻜﺎن‬
‫اﻳﺠﺎد ﺑﺮﻧﺎﻣﻪ ﻫﺎﺋﻲ را ﻓﺮاﻫﻢ ﻣﻲ ﻧﻤﺎﻳﺪ ﻛﻪ ﻗﺎدرﻧﺪ ﻣﺴﺘﻘﻞ از ﻧﻮع ﭘﺮوﺗﻜﻞ اﺳﺘﻔﺎده ﺷﺪه ‪ ،‬ﺑﺎ ﻳﻜﺪﻳﮕﺮ ارﺗﺒﺎط ﺑﺮﻗﺮار‬
‫ﻧﻤﺎﻳﻨﺪ ‪ .‬اﻳﻦ ﻧﻮع ﺑﺮﻧﺎﻣﻪ ﻫﺎ ﻣﻲ ﺗﻮاﻧﻨﺪ ﺑﺴﺎدﮔﻲ درﺧﻮاﺳﺘﻲ را اﻳﺠﺎد و ﭘﺎﺳﺦ آن را از ﻃﺮﻳﻖ ﻳﻚ ‪ URL‬ﺑﺪون‬
‫آﮔﺎﻫﻲ از ﺟﺰﺋﻴﺎت ﻣﺮﺑﻮﻃﻪ ‪ ،‬درﻳﺎﻓﺖ ﻧﻤﺎﻳﻨﺪ‪ ، System.Net .‬ﻫﻤﭽﻨﻴﻦ ﺷﺎﻣﻞ ‪ namespace‬زﻳﺮﻣﺠﻤﻮﻋﻪ‬
‫‪ System.Net.Sockets‬اﺳﺖ ‪ .‬ﻧﻮع ﻫﺎ ي ﻣﻮﺟﻮد در ‪ namespace‬ﻓﻮق ‪ ،‬ﻳﻚ ﭘﻴﺎده ﺳﺎزي ﻣﺪﻳﺮﻳﺖ ﻳﺎﻓﺘﻪ از‬
‫اﻳﻨﺘﺮﻓﻴﺲ ﻫﺎي ﻣﺒﺘﻨﻲ ﺑﺮ ﺳﻮﻛﺖ ﺳﻨﺘﻲ در ارﺗﺒﺎط ﺑﺎ ‪ TCP‬و ﻳﺎ ‪ UDP‬ﻣﺮﺑﻮط ﺑﻪ ‪ WinSock‬ﺑﺮاي ﺗﻮﻟﻴﺪات‬
‫ﻣﺒﺘﻨﻲ ﺑﺮ دات ﻧﺖ ‪ ،‬ﻣﻲ ﺑﺎﺷﺪ ‪ ، System.Net.‬اﻣﻜﺎﻧﺎت ﺣﻤﺎﻳﺘﻲ ﻻزم ﺑﻤﻨﻈﻮر دﺳﺘﻴﺎﺑﻲ ﺑﻪ ‪ HTTP,TCP‬و ﺳﺎﻳﺮ‬
‫ﭘﺮوﺗﻜﻞ ﻫﺎ را ﻓﺮاﻫﻢ ﻣﻲ ﻧﻤﺎﻳﺪ‪.‬‬
‫‪DNS‬‬

‫‪ ،System.IO‬ﻣﺠﻤﻮﻋﻪ اي ﮔﺴﺘﺮده از ﻧﻮع ﻫﺎ را ﺑﻤﻨﻈﻮر ﺧﻮاﻧﺪن و ﻧﻮﺷﺘﻦ ﻓﺎﻳﻞ ﻫﺎ و داﻳﺮﻛﺘﻮري ﻫﺎ ‪،‬‬
‫اراﺋﻪ ﻣﻲ ﻧﻤﺎﻳﺪ‪ .‬ﺑﺎ اﻳﻨﻜﻪ دﺳﺘﻴﺎﺑﻲ ﺑﻪ ﺳﻴﺴﺘﻢ ﻫﺎي ﻣﺪﻳﺮﻳﺖ ﺑﺎﻧﻚ اﻃﻼﻋﺎﺗﻲ ‪ ،‬اﻏﻠﺐ ﺑﻌﻨﻮان اﺻﻠﻲ ﺗﺮﻳﻦ روﻳﻜﺮد‬
‫ﺑﻤﻨﻈﻮر دﺳﺘﻴﺎﺑﻲ ﺑﻪ داده ﻫﺎ ﻣﻄﺮح ﻣﻲ ﮔﺮدد ‪ ،‬وﻟﻲ اﻣﻜﺎن اﻧﺠﺎم ﻋﻤﻠﻴﺎت ﻣﺮﺗﺒﻂ ﺑﺎ ﻓﺎﻳﻞ ﻫﺎ ‪ ،‬ﻫﻤﭽﻨﺎن ﻣﻔﻴﺪ و‬
‫ﺿﺮوري ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬
‫‪ ،System.Threading‬ﻳﻜﻲ دﻳﮕﺮ از ‪namespace‬ﻫﺎي ﻣﻬﻢ ﻓﺮﻳﻤﻮرك دات ﻧﺖ ﻣﺤﺴﻮب ﻣﻲ‬
‫ﮔﺮدد‪ .‬ﻧﻮع ﻫﺎي ﻣﻮﺟﻮد در ‪namespace‬ﻓﻮق ‪ ،‬روﺷﻲ اﺳﺘﺎﻧﺪارد ﺑﺮاي ﭘﻴﺎده ﻛﻨﻨﺪﮔﺎﻧﻲ ﻛﻪ ﺑﺎ ﻫﺮ ﻳﻚ از زﺑﺎﻧﻬﺎي‬
‫دات ﻧﺖ ﻛﺎر ﻣﻲ ﻧﻤﺎﻳﻨﺪ را ﺑﻤﻨﻈﻮر اﻳﺠﺎد ﺑﺮﻧﺎﻣﻪ ﻫﺎي ‪multithreaded‬اراﺋﻪ ﻣﻲ ﻧﻤﺎﻳﺪ‪ .‬ﻗﺒﻞ از دات ﻧﺖ ‪،‬‬
‫وﻳﮋوال ﺑﻴﺴﻴﻚ ‪،‬‬

‫‪C++‬‬

‫و ﺳﺎﻳﺮ زﺑﺎﻧﻬﺎ ﺟﻤﻠﮕﻲ داراي روﻳﻜﺮد ﻣﺨﺘﺺ ﺑﺨﻮد ﺑﻤﻨﻈﻮر‬

‫ﻓﺮﻳﻤﻮرك دات ﻧﺖ ﺗﻤﺎﻣﻲ زﺑﺎن ﻫﺎي ﻣﺒﺘﻨﻲ ﺑﺮ ‪ ،CLR‬ﻗﺎدر ﺑﻪ اﺳﺘﻔﺎده از ﻣﺤﺘﻮﻳﺎت‬
‫ﺑﻤﻨﻈﻮر ﻛﺎر ﺑﺎر‬

‫‪threads‬‬

‫‪threading‬‬

‫ﺑﻮدﻧﺪ‪ .‬در‬

‫‪System.Threading‬‬

‫ﺑﺼﻮرت ﻳﻜﭙﺎرﭼﻪ ﻣﻲ ﺑﺎﺷﻨﺪ ‪ .‬ﺷﺎﻳﺪ ﻣﻬﻤﺘﺮﻳﻦ ﻧﻮع در اﻳﻦ ‪ ،namespace‬ﻛﻼس‬

‫‪ Thread‬ﺑﺎﺷﺪ ﻛﻪ ﻣﺘﺪﻫﺎي ﻻزم ﺑﻤﻨﻈﻮر ﺷﺮوع ﻓﻌﺎﻟﻴﺖ ﻳﻚ ‪ ،thread‬ﺗﻮﻗﻒ آن و ﺳﺎﻳﺮ ﻋﻤﻠﻴﺎت ﻣﺮﺑﻮﻃﻪ را‬
‫اراﺋﻪ ﻣﻲ‬

‫ﻧﻤﺎﻳﺪ‪.‬‬

Sign up to vote on this title
UsefulNot useful