clsServerCommunication.cs
上传用户:hkhxjs
上传日期:2008-11-25
资源大小:155k
文件大小:12k
源码类别:

Internet/网络编程

开发平台:

C#

  1. namespace WorkingWithXML
  2. {
  3.     using System; // Provides the basic functionality of .NET
  4. using System.Net; // Provides the net related functionality 
  5. using System.IO; // Provides the I/O functionality
  6. using System.Text; // Provides text based manipulations
  7. using System.Windows.Forms; // Provides the use of graphic interface
  8. using System.Web;
  9.     /// <summary>
  10.     ///    Summary description for ServerCommunication.
  11.     ///    This class is responsible for all the communication with
  12.     ///    the server as well as Listener
  13.     ///    It has got some handy functions which can be very helpful
  14.     ///    like: GetIPAddress, FileDelete etc
  15.     /// </summary>
  16.     public class ServerCommunication
  17.     {
  18.         /// <summary>
  19.         /// Default constructor of the class
  20.         /// This cinstructor of the class is generated automatically
  21.         /// by the IDE
  22.         /// </summary>
  23. public ServerCommunication()
  24.         {
  25. }
  26. /// <summary>
  27. /// Get the response data from server represented by WebAddress
  28. /// When the request is made to the server it opens a stream
  29. /// to the response and the function read bytes from that 
  30. /// response stream and convert them to string and returns the value
  31. /// </summary>
  32. /// <param name="WebAddress"> </param>
  33. public string GetDataFromServer(string WebAddress)
  34. {
  35. // Declares a local variable webRequest of type HttpWebRequest
  36. // which is a part of System.Net package. It is used to form
  37. // an HttpRequest and sends it to the server
  38. HttpWebRequest webRequest;
  39. // Declares a local variable webResponse of type HttpWebResponse
  40. // which is a part of System.Net package. It is used to get the
  41. // response from the server against the HttpWebRequest 
  42. HttpWebResponse webResponse;
  43. // Declares a variable responseStream of Stream type which is 
  44. // use to get the response from the server's end
  45. Stream responseStream;
  46. // streamBuffer variable is declared here of type Byte array
  47. // this is used to read the actual data from the responseStream
  48. Byte[] streamBuffer;
  49. // Declares a variable ReturnData of type string which
  50. // at last stores the data which is to be returned
  51. string ReturnData;
  52. // initializes the ReturnData to null
  53. ReturnData = null;
  54. // Creates and initializes a webRequest by calling Create
  55. // function of the WebRequestFactory and type cast it to
  56. // HttpWebRequest type
  57. webRequest = (HttpWebRequest)WebRequest.Create(WebAddress);
  58. // After requesting the server for HttpWebRequest
  59. // it will opens a response for the clients end to read
  60. // this response is catched by the foloowinf line of code
  61. // and assigns it to webResponse
  62. webResponse =(HttpWebResponse)webRequest.GetResponse();
  63. // GetResponseStream method of webResponse actually gets
  64. // the response stream and assigns it to the responseStream
  65. responseStream = webResponse.GetResponseStream();
  66. // initialize streamBuffer so that it can read 16 bytes of data
  67. // at a time
  68. streamBuffer = new Byte[16];
  69. // Declares a int variable iBytesRead which keeps the
  70. // records of how many bytes have been read from the
  71. // stream
  72. int iBytesRead;
  73. // Reads 16 bytes from the stream until the stream gets
  74. // enpty and the value assigned to iBytesRead is zero
  75. while( 0 != (iBytesRead = responseStream.Read(streamBuffer, 0, 16)) )
  76. // This will convert the bytes data that is read from the
  77. // stream and stored in streamBuffer to string and concatenates
  78. // it to ReturnData
  79. ReturnData += Encoding.ASCII.GetString(streamBuffer, 0, iBytesRead);
  80. // Removes the leading and trailing spaces from the Data
  81. // that is stored is returnData variable
  82. if( ReturnData != null )
  83. {
  84. ReturnData = ReturnData.Trim();
  85. // ReturnData = ReturnData.Substring(0,ReturnData.LastIndexOf("</p2p_lng>") + "</p2p_lng>".Length );
  86. }
  87. // Flushes the responseStream
  88. responseStream.Flush();
  89. // Closes the responseStream
  90. responseStream.Close();
  91. // Returns the value of ReturnData variable
  92. return ReturnData;
  93. }
  94. /// <summary>
  95. /// Get the response data from server represented by WebAddress
  96. /// using Proxy server. When the request is made to the server it 
  97. /// opens a stream to the response and the function read bytes 
  98. /// from that response stream and convert them to string and 
  99. /// returns the value
  100. /// </summary>
  101. /// <param name="WebAddress"> </param>
  102. public string GetDataFromServerUsingProxy(string WebAddress, string ProxyAddress, int Port)
  103. {
  104. // Declares a local variable webRequest of type HttpWebRequest
  105. // which is a part of System.Net package. It is used to form
  106. // an HttpRequest and sends it to the server
  107. HttpWebRequest webRequest;
  108. // Declares a local variable webResponse of type HttpWebResponse
  109. // which is a part of System.Net package. It is used to get the
  110. // response from the server against the HttpWebRequest 
  111. HttpWebResponse webResponse;
  112. // Declares a variable responseStream of Stream type which is 
  113. // use to get the response from the server's end
  114. Stream responseStream;
  115. // streamBuffer variable is declared here of type Byte array
  116. // this is used to read the actual data from the responseStream
  117. Byte[] streamBuffer;
  118. // Declares a variable ReturnData of type string which
  119. // at last stores the data which is to be returned
  120. string ReturnData;
  121. // initializes the ReturnData to null
  122. ReturnData = null;
  123. System.Net.IWebProxy ProxyData = new System.Net.WebProxy(ProxyAddress,Port);
  124. // Creates and initializes a webRequest by calling Create
  125. // function of the WebRequestFactory and type cast it to
  126. // HttpWebRequest type
  127. webRequest = (HttpWebRequest)WebRequest.Create(WebAddress);
  128. webRequest.Proxy = ProxyData;
  129. // After requesting the server for HttpWebRequest
  130. // it will opens a response for the clients end to read
  131. // this response is catched by the foloowinf line of code
  132. // and assigns it to webResponse
  133. webResponse =(HttpWebResponse)webRequest.GetResponse();
  134. // GetResponseStream method of webResponse actually gets
  135. // the response stream and assigns it to the responseStream
  136. responseStream = webResponse.GetResponseStream();
  137. // initialize streamBuffer so that it can read 16 bytes of data
  138. // at a time
  139. streamBuffer = new Byte[16];
  140. // Declares a int variable iBytesRead which keeps the
  141. // records of how many bytes have been read from the
  142. // stream
  143. int iBytesRead;
  144. // Reads 16 bytes from the stream until the stream gets
  145. // enpty and the value assigned to iBytesRead is zero
  146. while( 0 != (iBytesRead = responseStream.Read(streamBuffer, 0, 16)) )
  147. // This will convert the bytes data that is read from the
  148. // stream and stored in streamBuffer to string and concatenates
  149. // it to ReturnData
  150. ReturnData += Encoding.ASCII.GetString(streamBuffer, 0, iBytesRead);
  151. // Removes the leading and trailing spaces from the Data
  152. // that is stored is returnData variable
  153. if( ReturnData != null )
  154. {
  155. ReturnData = ReturnData.Trim();
  156. // ReturnData = ReturnData.Substring(0,ReturnData.LastIndexOf("</p2p_lng>") + "</p2p_lng>".Length );
  157. }
  158. // Flushes the responseStream
  159. responseStream.Flush();
  160. // Closes the responseStream
  161. responseStream.Close();
  162. // Returns the value of ReturnData variable
  163. return ReturnData;
  164. }
  165. /// <summary>
  166. /// Writes the DataToWrite to Filename
  167. /// This function writes the string data which is stored in
  168. /// DataToWrite variable to the file pointed by Filename
  169. /// Usually we write XML file
  170. /// </summary>
  171. /// <param name="Filename"> </param>
  172. /// <param name="DataToWrite"> </param>
  173. public void WriteDataToFile(string Filename, string DataToWrite)
  174. {
  175. // Declares and initializes the FileToCreate variable of 
  176. // type File and passess Filename to its constructor to 
  177. // associate it with the File
  178. //File FileToCreate = new File(Filename);
  179. // Addedd for Beta 2
  180. FileStream WriteStream = new FileStream(Filename,FileMode.Create);
  181. // Deaclares and creates a WriteStream object, used
  182. // to write the data to the stream which is present
  183. // in DataToWrite variable
  184. //Stream WriteStream = FileToCreate.OpenWrite();
  185. // Writes the data to the file by converting data
  186. // to byte format
  187. WriteStream.Write(Encoding.ASCII.GetBytes(DataToWrite), 0, DataToWrite.Length);
  188. // Closes the written file
  189. WriteStream.Close();
  190. }
  191. /// <summary>
  192. /// Determine the type of request/response recived in XML
  193. /// This is done by extracting the attribute value from the
  194. /// first node value of first child element of the document
  195. /// </summary>
  196. /// <param name="XMLFilename"> </param>
  197. public string TypeOfXMLRecieved(string XMLFilename)
  198. {
  199. // Declares and initializes a local variable document
  200. // of type IXMLDOMDocument present in MSXML2 class. This
  201. // variable is used to point to the XML filename or document
  202. MSXML2.IXMLDOMDocument document = new MSXML2.DOMDocument();
  203. // Declares a local variable element of type IXMLDOMElement
  204. // This is used to point to the elements present in the XML
  205. // document
  206. MSXML2.IXMLDOMElement element;
  207. // Declares a local variable node of type IXMLDOMElement
  208. // This is used to point to the nodes present in the XML
  209. // Document
  210. MSXML2.IXMLDOMNode node;
  211. // A local variable NodeValue is declared of type string 
  212. // it is used to store the retrieved value from the XML and 
  213. // returns it from the function
  214. string NodeValue;
  215. // Read the XML document syncronously
  216. document.async = false;
  217. // Initializes NodeValue to null
  218. NodeValue = null;
  219. // Loads the XML document for reading
  220. if( document.load(XMLFilename) )
  221. {
  222. // Extract the first element of the XML
  223. element = document.documentElement; 
  224. // Extract the first child node from the element
  225. // and stores it to the node
  226. node = element.firstChild;
  227. // now extract the first node value from the attributes
  228. // present in the XML and saves it to NodeValue
  229. NodeValue = node.attributes.nextNode().nodeValue.ToString(); 
  230. }
  231. // Simply returns the NodeValue variable
  232. return NodeValue;
  233. }
  234. /// <summary>
  235. /// This function is used to delete a file represented by filename
  236. /// </summary>
  237. /// <param name="Filename"> </param>
  238. public void FileDelete(string Filename)
  239. {
  240. // Declares and initializes an object f of type File which is
  241. // present in System.IO package and assigns Filename to it
  242. //File f = new File(Filename);
  243. //Added for Beta 2
  244. File.Delete(Filename);
  245. // Calls the Delete function of File Class to delete the 
  246. // file represented by Filename
  247. //f.Delete();
  248. }
  249. /// <summary>
  250. /// Retrieve the IP Address of the machine represented by
  251. /// Hostname. This function makes the use of the DNS class
  252. /// for extracting the IP address and returns the first entry
  253. /// from the IP list obtained
  254. /// </summary>
  255. /// <param name="Hostname"> </param>
  256. public string GetIPAddress(string Hostname)
  257. {
  258. // Creates a new local variable named LocalHost of type
  259. // IPHostEntry which is present in the System.Net package
  260. // It then calls the GetHostByName function of the DNS class
  261. // and passes the Hostname to it
  262. IPHostEntry LocalHost = Dns.GetHostByName(Hostname); // To retrieve my computer's IP
  263. // Now the LocalHost has got the list of IPs corresponding
  264. // to the hostname and it will return the first entry from the
  265. // list
  266. return LocalHost.AddressList[0].ToString();
  267. }
  268.     }
  269. }